Changelog
Tracked updates to RunwayCtrl as we build v0.1.
Entries are factual and date-stamped.
✓Shipped
🛠In progress
🔭Planned
Known issues
- •Implementation is in early stages; entries reflect planned work.
- •Timelines are approximate and may shift based on design partner feedback.
- •Some features may evolve significantly before release.
Added
- +Added approvals workflow as a first-class approval-required path so actions can be gated before proceeding, including full lifecycle and status handling.
- +Introduced blast-radius controls to constrain impact during execution and protect downstream systems.
- +Tightened staged rollout semantics so rollout progression can be controlled and paused based on safety conditions.
- +Added GitHub webhook receiver support, enabling approval-style automation via GitHub events.
- +Added PagerDuty webhook support to tie operational events into the control-plane workflow.
- +Expanded OpenAPI contract to document new approvals and guardrails related surfaces, maintaining semantics-first discipline.
- +Updated Node SDK to support new server capabilities and related error/response handling.
- +Updated shared schemas so Console, SDK, and Control Plane agree on the same v1 shapes.
- +Added integration coverage around approvals and guardrails behavior with database-backed tests.
- +Included new database migrations to support approvals and rollout semantics.
- +Tightened CI discipline so OpenAPI changes now require corresponding validation.
Enables human-in-the-loop approvals for high-risk actions, provides blast-radius controls to limit impact, and connects external operational events (GitHub, PagerDuty) directly into governed execution flows with full auditability.
Added
- +Added richer request correlation identifiers to attempt details, making it easier to tie together API requests, tool outcomes, and client-side troubleshooting.
- +Enhanced the attempt view with clearer tool execution metadata (e.g., status and timing) to speed up debugging and support workflows.
- +Introduced optional trace deep-linking support so teams can jump from an attempt to their tracing system when configured.
- +Improved operational documentation and deployment scaffolding to support smoother environment setup and verification workflows.
Reduces mean time to resolution during incidents by providing clear correlation paths from attempt failures to root causes, with direct links to distributed tracing systems for end-to-end visibility.
Added
- +Added new web console that provides read-only operational view into what RunwayCtrl is doing, including pages for Scoreboard, Actions, Action details, Attempts, Attempt details, Leases, and Circuit breaker state.
- +Built-in copy link and copy ID helpers to make sharing investigations easy across teams during incidents or debugging sessions.
- +Added filtering and time-range controls on key lists so you can zoom in on specific incident windows and narrow down relevant execution data.
- +Improved pagination behavior so filters carry forward as you page through results, maintaining context throughout navigation.
- +Action details now show the most useful metadata (tool, action name, timestamps, terminal status) plus a quick timeline of recent attempts for rapid diagnosis.
- +Attempt details now show key execution fields (status, timestamps, hashes/pointers, retries, lease events) and trace link when available for distributed tracing correlation.
- +Added backend read-only APIs to power the console's dashboard views and operational queries.
- +Introduced begin observation audit/read-model record so scoreboard metrics can be computed reliably from the system's own decisions, not just external metrics.
- +Updated public API contract (OpenAPI) and shared schemas to match new console and read-model capabilities.
- +Added and expanded integration tests to validate new endpoints and data returned by the console APIs.
Transforms RunwayCtrl from a black box into an observable system where teams can quickly understand execution state, investigate incidents, and share precise links to specific actions or attempts without requiring database access or custom tooling.
Added
- +Shipped new PagerDuty and GitHub integrations with deterministic execution semantics, including idempotency via stable request keys and replay of terminal outcomes to prevent duplicate side effects.
- +Implemented provider-aware error classification (auth vs validation vs rate limit vs server) and surfaced upstream request identifiers for easier incident and debug correlation without leaking sensitive payloads.
- +Added concurrency controls through resource-scoped serialization, enabling safe automation on race-prone operations (e.g., incident state transitions, PR merges) while allowing parallelism where appropriate (e.g., notes/comments).
- +Delivered DevEx improvements in the Node SDK: env-based client configuration, safer error summaries, and reusable helpers to standardize resource scoping across integrations.
- +Published runnable, developer-oriented examples that demonstrate end-to-end safe automation flows (including replay behavior) against a locally running control plane.
- +Strengthened engineering hygiene with updated security guidance and automated dependency/security scanning to keep daily shipping sustainable.
Brings RunwayCtrl's execution governance to real-world incident management and developer workflows, preventing duplicate incidents, conflicting automations, and race conditions while providing clear debugging signals and production-ready integration patterns.
Added
- +Improved request tracing so developers can more easily follow an execution from start to final outcome, reducing time-to-diagnosis when issues occur.
- +Added additional telemetry coverage for key API operations and outcomes to help diagnose issues faster with better signal quality and less noisy telemetry.
- +Stronger protections against misuse and abuse patterns including overly aggressive retry traffic and high request volumes.
- +Safer defaults to reduce the chance of sensitive data being exposed via logs or telemetry.
- +Clearer runbooks and operational guidance for common incidents such as latency spikes, denial spikes, and unknown outcomes.
- +Improved resilience when traffic patterns get spiky or bursty, helping the service stay responsive and predictable under pressure.
Changed
- ~No breaking API changes were introduced. This release focuses on visibility, safety, and stability improvements.
Enables faster debugging through better traceability, provides safer defaults to prevent accidental overload and reduce exposure risk, and builds greater confidence for production integrations with improved operational documentation and predictable behavior under load.
Added
- +Released official TypeScript SDK packages: @runwayctrl/sdk-core for shared utilities and @runwayctrl/sdk-node for Node.js client with execution wrapper.
- +Introduced one-call execute workflow that coordinates request → governance decision → tool execution → completion, returning the same outcome when the same semantic action is repeated.
- +Added pluggable tool adapters for OpenAI, Anthropic, Azure OpenAI, and Gemini with consistent success/failure/unknown-outcome shapes for uniform error handling across providers.
- +Implemented first-class cancellation support with AbortSignal so callers can cleanly cancel long waits or tool executions.
- +Added safer retry behavior with configurable guardrails to prevent run-forever scenarios (max attempts, max time ceilings).
- +Published comprehensive SDK documentation with integration guides and readiness notes for safe production adoption.
- +Introduced Changesets configuration for monorepo publishing hygiene to support future versioning and changelog workflows.
Changed
- ~SDK defaults emphasize deterministic behavior to improve testing and debugging experiences, with future ergonomic improvements planned for later phases.
Provides a production-ready entry point for Node.js/TypeScript applications to wrap model and tool calls in RunwayCtrl-managed execution with consistent results on repeats, unified error handling, and clean cancellation support.
Added
- +Added governed execution controls to reduce retry storms and protect downstream tools from excessive load.
- +Introduced rate limiting with clear retry_after_ms guidance so callers know exactly when to slow down and retry.
- +Added circuit breaking capability allowing the control plane to temporarily deny calls when a tool or action is detected as unhealthy.
- +Improved retry and backoff behavior so repeated failures lead to progressively longer recommended wait times, preventing aggressive retry loops.
- +Made retry exhaustion deterministic: when an action exceeds its retry budget, callers receive a stable terminal result (ATTEMPT_CAP_EXCEEDED) instead of retrying forever.
- +Expanded observability signals around governor decisions to make behavior easier to understand and debug in production environments.
- +Updated API contract and documentation to reflect new governor behaviors and failure outcomes.
Protects downstream systems from retry storms and provides predictable failure modes when actions exhaust their retry budgets, eliminating runaway retry loops without requiring custom rate limiting logic.
Added
- +Introduced resource-level concurrency control using TTL leases plus FIFO fairness queue for coordinating multiple agents targeting the same resource_key.
- +Added developer-selectable lease_mode: fail fast (return error on contention) or queue and wait (return waiter_id for polling queue position).
- +Implemented lease management endpoints to query lease status, advance queue position, and manually release leases when needed.
- +Added early lease release on attempt completion to reduce wait time while maintaining TTL as a safety net against stuck/abandoned leases.
- +Integrated lease lifecycle with the action execution model so lease grants and releases are transactionally consistent with attempt state changes.
Enables safe, predictable coordination under resource contention without requiring developers to build their own locking, fairness, or retry orchestration logic.
Added
- +Deterministic replay behavior for duplicate requests: repeated calls using the same action identifier now reliably return the prior terminal outcome instead of creating duplicate work.
- +Better handling of in-flight work: when an action is already running, the API returns a clear pending response with optional join window where the server waits briefly and returns the terminal outcome if it completes.
- +Richer terminal metadata: successful and replayable failed outcomes now include additional terminal details for easier correlation and debugging.
- +Improved failure replay support with safe defaults: certain non-retryable failures are treated as terminal and replayable to avoid repeated pointless retries and reduce noise.
- +Stronger persistence guarantees: database schema updates support replay, join/pending behavior, and policy fields with safe guardrails to keep data consistent over time.
- +Expanded automated test coverage validating replay, join/pending behavior, and terminalization paths to reduce regression risk.
Changed
- ~No client-breaking API shape changes; this is primarily a correctness and behavior hardening update.
Hardens the governance layer to ensure deterministic replay, cleaner client ergonomics for in-flight actions, and more reliable terminal outcome handling without breaking existing integrations.
Added
- +Introduced Action Lifecycle API for starting work and reporting outcomes, enabling intelligent execution decisions at the boundary.
- +Added decision-based BeginAction response supporting Proceed (start new attempt), Pending (work in progress), and Replay Success (reuse previous successful outcome) to prevent duplicate side effects.
- +Added outcome reporting endpoints to mark attempts as successful (with outcome reference), failed (with classified failure reason), or unknown (for timeout/network ambiguity scenarios).
- +Added Action Status endpoint to query current execution state and retrieve basic execution history counts for observability.
- +Improved idempotency and concurrency behavior so repeated requests do not create duplicate side effects or conflicting work.
- +Strengthened input validation and standardized error responses across all endpoints for a more predictable client experience.
Delivers the core control plane that agents use to safely coordinate work, avoid duplicate actions, and surface execution history without requiring custom deduplication logic.
Added
- +Introduced durable execution ledger with tenant-scoped records for actions, attempts, events, and leases to enable reliable audit trails and replay workflows.
- +Added data access layer with connection pooling and transaction helpers to enforce atomic writes and consistent rollback behavior across all operations.
- +Implemented deterministic event retrieval with stable ordering to support reliable debugging and replay workflows in production environments.
- +Added seed tooling for local and development environments, including one-time credential issuance with hash-only storage to avoid persisting plaintext secrets.
- +Expanded automated test coverage with database-backed integration tests validating tenant isolation boundaries and transactional invariants.
- +Updated architecture and security documentation to reflect implemented data-handling patterns and operational guardrails.
Establishes the durable truth source that enables deduplication, audit trails, and reconstructible execution history with strong tenant isolation guarantees.
Added
- +Established foundational workspace and development workflow, including a local environment to run the service and its dependencies.
- +Added minimal health endpoint to validate that the system starts cleanly and responds as expected.
- +Introduced automated quality gates (formatting, linting, type checks, and test runs) to keep code hygiene consistent as development accelerates.
- +Added documentation conventions and configuration guardrails (template-based environment setup + ignore rules).
- +Created Phase 0 checkpoint tag to enable reproducible milestones and quick rollback.
Establishes the foundational workspace that enables rapid, reliable iteration while maintaining quality and reproducibility from day one.
Added
- +Published "How it works" copy aligned to the core contract: action identity → governance → receipts → trace linkage.
- +Defined Integrations page structure (hub + deep dives) to communicate initial support without overpromising.
Changed
- ~Tightened language to avoid "GA vibes" while staying precise about the reliability guarantees.
Sets a consistent public contract before implementation lands.
Design partners
Design partners get early builds + a tight feedback loop.