Codex AutorunnerCoding agents that finish, not just run.
Coding agents are sharp in short bursts and unreliable across long runs. They drift — not because they run out of context window, but because the task itself dissolves into a growing transcript of their own output.
Codex Autorunner (CAR) is a meta-harness that re-grounds every iteration against the active ticket, shared context docs, and the real repo state. Agents stay on goal across hours of autonomous work, in parallel, while you review in batch.
Open source. Bring your own coding agent — Codex CLI, Claude Code, or anything that runs in a shell.
Long runs don't fail from context length. They fail from drift.
Watch a coding agent for ten minutes and it looks brilliant. Watch it for two hours and you see the failure mode: the task itself quietly mutates. Each iteration inherits a noisier, fuzzier picture of what it was supposed to be doing.
Compaction shortens the transcript but doesn't fix this. The summary becomes a second-order prompt — smaller, but still a lossy retelling of the work. The agent is now grounded in fiction.
- The active task becomes implicit, buried inside transcript sprawl.
- Tool noise, stale plans, and old interpretations all carry forward as "context."
- By hour three, the agent is solving a problem nobody asked for.
The agent isn't slow. It's unanchored. Give it the same task framing on iteration 30 that it had on iteration 1, and it keeps shipping.
Think of it as a Brownian bridge.
A naive agent loop is a random walk: locally noisy, globally unbounded. Confidence in where the agent is heading widens with every turn.
A Brownian bridge is still noisy locally — but it's conditioned on explicit anchor points. The trajectory wanders, but it has to pass through fixed milestones on its way to a known endpoint.
CAR creates those anchors. Every iteration is reconditioned on the current ticket, the spec, the contextspace, and the real repo state. The agent stays stochastic in the small. It stays bounded in the large.
The control plane lives in tickets, not chat history.
CAR isn't a coding agent. It's a state machine: while there are open tickets, pick the next one and run it against an agent of your choice. Tickets are the control plane. Agents are the execution layer.
Because the contract lives in tickets and durable docs — not in ephemeral chat memory — a fresh agent can pick up mid-run. You can edit the plan while it's in flight. You can swap Opencode for Codex CLI between iterations. The work survives.
ticket --+ ticket --+ ticket --+
v v v
+-----------------------------+
| CODEX AUTORUNNER |
| select ground constrain |
| execute persist resume |
+--------------+--------------+
v
engineer
(direction + review)What happens on every turn.
Select
Pick the next unfinished ticket in order. The unit of work is explicit, not implied.
Ground
Load the ticket plus durable context — spec, decisions, active context, repo state.
Constrain
Carry forward only the previous final output when continuing the same ticket. No transcript soup.
Execute
Let the agent explore freely inside a tightly bounded work packet, in its own git worktree.
Persist
Store results, update ticket state, queue the diff for review. The next turn starts from explicit state.
Three loops, three trajectories.
What you actually get.
Bounded long runs
Agents work across many turns without the task dissolving into summary artifacts. Hours of autonomy, not minutes.
Parallel worktrees
Fan out across independent tickets. Each agent gets an isolated git worktree. No stepping on each other's branches.
Agent-agnostic
Codex CLI, Claude Code, or anything that runs in a shell. Swap models between iterations without losing state.
Inspectable state
Tickets, specs, and contextspace docs are plain files. Reviewable and editable mid-run. Nothing hides in chat memory.
Clean handoffs
Any fresh agent can resume because the contract lives outside the transcript. Restart-safe by construction.
Batch review
Diffs queue up. You approve, iterate, or discard at your own pace — without being the bottleneck between every prompt and every commit.
Open source
Run it on your own infrastructure. No SaaS in the loop, no vendor lock-in, no telemetry tax.
Solo-operator leverage
Built for engineers and founders who want team-scale output without team-scale headcount.
Direction is your job. Transcription isn't.
You should be setting goals, making judgment calls, and reviewing real diffs. You shouldn't be re-explaining the task to a confused agent at 11pm because its own history poisoned its context.
CAR is the harness you'd build yourself after the third multi-hour run that quietly veered off-task. It's already built. It's open source. Install it and let your agents actually finish.
As models get stronger, the harness should give more and more power to the agent. CAR is bitter-lesson pilled by giving agents full access to CAR, just as you do. This means that as models get better at planning future work, empathizing with other agents, and understanding their own limits, they will also get better at authoring tickets, which allows agents to use tickets as a meta-programming language.
Get updates on Scaling Forever and our companies. New launches, essays, and tools in your inbox or feed.
Scaling Forever v1.0 — AI-Native Startup Studio Type 'help' for commands · Press / to focus