Runway

Air traffic control for Codex agents sharing a repo.

Comment

Inspiration

This is not a synthetic-only failure shape. One public ESLint issue produced three independent human implementations. Two later pull requests were closed to avoid duplicating work. Git eventually exposed the coordination failure, but only after contributors had already written code. That evidence proves duplicate implementation is real and reconstructable; it does not prove AI agents collide at scale.

The agent-specific premise comes from a separate primary source: official Codex documentation says parallel write-heavy agent workflows can create conflicts and increase coordination overhead. Runway targets that documented boundary without pretending the historical contributors were agents.

Worktrees isolate edit locations and merge tools resolve completed changes. Neither asks the earlier question: before two agents start, do they intend to change the same behavior?

What it does

Runway connects forensic proof to prevention.

Collision Replay accepts two Git ranges, resolves exact commit SHAs, extracts changed JavaScript/TypeScript paths and changed function declarations, and feeds both scopes through Runway's deterministic collision engine. The bundled public replay reconstructs ESLint PRs #20248 and #20487. It finds four shared paths and the same changed function, then emits a SHA-256-fingerprinted JSON artifact. The replay is explicitly counterfactual and human-authored: it proves overlap existed; it does not claim Runway was deployed there or measure agent-collision prevalence.

Live lanes turn the lesson into a code-scope contract. Before implementation, each agent declares expected files, exported symbols, and behavioral contracts. Runway returns an inspectable clear, caution, protected-owner, or hold decision. Direct scope overlap can stop the later lane; shallow dependency proximity remains a caution, not false certainty.

Native Codex guard narrows the cooperative-declaration gap. The installable plugin binds each Codex process to RUNWAY_LANE. Its trusted PreToolUse hook inspects direct apply_patch/Edit/Write targets and denies missing, unknown, non-airborne, traversal, and out-of-lane paths before the patch runs.

Verified handoff remains the final backstop. lane verify executes the exact trusted test command itself, captures exit status, duration, output hashes, and byte counts, then re-reads staged, unstaged, and untracked Git paths. Only a successful command plus a conformant post-command audit creates a receipt. Manual passing handoffs are rejected.

The build includes an interactive React control tower, installable Codex marketplace plugin, auto-discovered skill, native patch hook, standalone dependency-free CLI, Parcel Ops source fixture, 39 tests, JSON state import/export, a published replay artifact, and a checked-in no-rebuild demo.

How we built it

The replay path, plugin CLI, and dashboard share the same dependency-free collision core. The CLI persists .runway/state.json, scans common JS/TS exports and relative imports, guards lane transitions, serializes local writers with an exclusive lock, and atomically replaces state. The hook reads the same persisted lane boundary before Codex patch calls.

The browser opens on the public collision replay, then moves to a concrete prevention flow. Pricing owns src/quote.js, quoteTotal, and the pricing contract. Tax independently declares all three and is held before editing. Rerouting Tax to src/tax/adjustments.js clears it. Checkout remains only a caution because an import is review evidence, not proof of conflicting intent.

How Codex and GPT-5.6 were used

Runway now runs natively inside Codex as an installable skill, trusted PreToolUse hook, and bundled CLI. It still makes no runtime GPT call. GPT-5.6 ran through Codex as the engineering environment that built and pressure-tested the product. It helped narrow the problem, implement the core, replay extractor, CLI verification gate, dashboard, plugin, hook protocol, concurrency, and adversarial tests. QA found and fixed Windows path normalization, symbol-case, ownership ordering, invalid transitions, concurrent writes, stale locks, diff drift, false-positive replay symbols, traversal, missing lane bindings, and inaccurate claims.

Keeping collision decisions deterministic is a product choice: judges can reproduce every hold, verification result, and Git audit without an API key or hidden model judgment. The official rules ask entrants to build with Codex/GPT-5.6, explain that collaboration, and provide the /feedback Codex Session ID; they do not state that the shipped runtime must call a model API.

The session of record is 019f6e9b-8401-78c0-a71b-56273ec52b3f; the evidence trail is in 03_build_log.md.

Challenges

The central challenge was credibility. A fixture alone could make Runway look like a linter built around its own example. Collision Replay grounds the failure shape in public Git history, while the visible evidence boundary states that the contributors were human and the replay is not agent-scale data. Official Codex guidance supplies the separate agent-workflow basis.

The second challenge was cooperative participation. A skill instruction alone could be ignored. The Codex hook now stops supported direct patches outside the active airborne lane before execution, while lane verify catches changed-file drift from shell, MCP, editor, or other paths afterward. Neither layer is described as universal enforcement.

The engineering challenge was safe local mutation. Runway locks writers, reloads state under lock, performs same-directory atomic replacement, and detects lane changes that occur while a verification command is running.

Accomplishments

  • Reconstructed a documented human duplicate-work incident from exact public Git refs without relabeling it as agent evidence.
  • Produced an inspectable replay with four shared paths, one shared changed function, source links, exact SHAs, and a verifiable fingerprint.
  • Converted that historical failure into a pre-edit hold using the same collision engine.
  • Shipped an installable Codex plugin whose trusted lifecycle hook denies direct out-of-lane patches before execution.
  • Distinguished direct overlap from an import-only caution.
  • Made test evidence Runway-executed rather than operator-asserted.
  • Rejected handoff after a passing command when the fresh Git audit found an undeclared file.
  • Shipped a public no-login demo, reproducible fixture, Codex plugin, standalone CLI, and 39 passing tests.

What we learned

Evidence must stay in its lane. Public history proves a duplicate-implementation failure; official product guidance establishes the agent-specific coordination risk; the working build proves Runway's mechanism. None alone proves prevalence or production impact. The useful control point is still a small, inspectable contract: declared before work, tested by the tool, and checked against Git after work.

What's next

Next steps are coverage for additional trusted write surfaces, opt-in language adapters, hunk-level symbol conformance, and a shared transport for distributed teams. This build does not claim compiler-grade analysis, distributed locking, universal write enforcement, autonomous intent detection, or guaranteed conflict-free merges.

Built With

Share this project:

Updates