Only Claude Survived

A month ago my AI coding harness ran three providers: Claude Code, Codex and Grok Build. Earlier this week it ran three again, a different three, with a local agent on my laptop in the third seat.

Today it runs one.

It started in early September with two, Claude Code and Codex, on one canonical policy. Grok Build joined the next day and made it a trio. Since then providers have mostly been leaving, and I wrote up every exit. This is the last one: the local agent, and with it nearly everything else that wasn't Claude.

The third mind

In The Third Mind: Local AI for When the Cloud Runs Out, I added a provider that never left the laptop: OpenCode on open-weight models, served by a llama.cpp router on my MacBook Pro M4 Max with 128 GB.

• Qwen3.8-27B, dense, for coding
• Qwen3.6-35B-A3B, mixture-of-experts, for fast work
• A decensored 27B for uncensored work

Around it I built a pile of plumbing: a nightly updater that evaluated and promoted new models, a request guard that kept every model call on the machine, and a local-only mode.

It had two jobs: uncensored work, and work that has to keep going when Claude and Codex are both out of quota.

The controlled duel looked fine. One well-specified mini project, 48 hidden tests, and both agents passed all 48. The local agent committed after 43 minutes, Claude after 26. Slower, but it got there, on a laptop, with no quota to run out of.

Then I gave it real everyday work. Simple tasks that Opus 5.5 finishes in 10 to 30 minutes took the local model hours. For real work, it's literally useless.

A sprint is not a workday

This section is analysis, not measurement: two numbers and my reading of what they do to an agent loop. The coding model, Qwen3.8-27B, wrote about 10 to 28 tokens per second and read the prompt (the prefill) at about 110 to 210, depending on the prompt and the laptop's state.

The duel was a clean room. A small context, little to explore, few ways to get lost. That's close to a best case for a local model, and it was still slower.

Simple isn't small. A simple task in a real repository still comes with a big context. My rules and the project's instructions are in it from the first step. Then the agent has to find its way around code it didn't write: search, open files, run tests, read logs. All of that lands in the context.

Agents read far more than they write. Every step of an agent loop sends the conversation back to the model. Prompt caching lets the server skip what it has already read, as long as the cache holds. But the new part is often the big part: the file it just opened, the test output, the diff. All of it gets read at 110 to 210 tokens per second, and a cache miss means reading everything again. At 150 tokens per second, a 60,000-token context is almost seven minutes before the model writes a word. With a cloud model you never think about reading. On a laptop it's where the time goes.

Lots of small round trips. Real work is search, open, edit, run, read the failure, edit again. Every step pays twice: first it reads whatever is new, then it writes the next move at 10 to 28 tokens per second. One slow step is fine. A long chain of them is your afternoon.

Weaker planning, more steps. A 27B plans worse than a frontier model. It's more likely to open the wrong file, misread an error or take the scenic route. Real work has plenty of wrong turns, and every one is paid at local speed.

Mistakes compound. A wrong assumption early doesn't cost one step. It costs every step built on top of it, then the steps to notice, then the steps to back out.

And someone waits. Saving my attention is the whole point of an agent. A task that takes hours either blocks me or turns into babysitting. A slow agent isn't a cheaper agent; its cost moves from dollars to hours.

In the duel the gap was minutes. On real work it was hours.

How the other two left

Grok went first, in I Fired My Busiest AI Reviewer. My own receipts said it was the busiest reviewer: it completed 269 of 390 review attempts, against Codex at 138 of 317 and Claude at 114 of 279. I cut it anyway. The bottleneck was Codex hitting its usage limit: tried first, it failed 60% of the time, almost always on the limit. So Grok's $300 a month went to ChatGPT Pro 500 for more Codex capacity. I called it a purchase, not a proof.

And if you're keeping score, Claude completed the fewest reviews of the three.

Codex went next, in Fuck You OpenAI. An overnight batch of about 24 Codex agents burned 57,500 credits in about 100 minutes, roughly 84% of it on gate-audit agents re-checking whether blocked tickets could start. One ticket of 29 got done. On top of that, OpenAI had left my Pro 500 plan on the old Pro 200 allowance until it fixed the error. I cancelled Pro 500, so the purchase from the Grok post is gone too. The provider I bought more of to replace Grok is the one that burned the credits.

After that the harness was Claude only, with the local agent kept around for me to open by hand.

Why Claude survived

Not because it won a fair fight. Grok lost its budget to Codex. Codex left after one expensive night and a plan that had sat on the wrong allowance. The local agent lost on speed. Nobody ran a final.

But Claude isn't just what was left over, either.

Fit and speed. My project rules were written for Claude; the others read them through forwarders and generated adapters. I hand real work to Claude Code with Opus 5.5, a 1M-token context and maximum effort, and it's the yardstick in the verdict above. That's a judgment from daily use, not a benchmark.

The complexity tax. Takeover records, sessions, handoffs, the loop driver, second opinions: each one grew an OpenCode branch, on top of what Codex and Grok had left behind, and each branch brought its own tests and docs. Before, every change had three places to land. Removing Grok touched 167 files. Removing Codex touched 245. And the tax doesn't care whether you use the other agents: the branches, the tests and the background jobs are there either way.

Every harness option that names a provider now accepts exactly one value: claude.

What I gave up

Running on one provider costs me real things.

Model-family diversity. A second opinion used to be able to come from another provider. Now a fresh, isolated Claude child reviews the evidence, with no tools, no memory and no project instructions. It's independent of the session that did the work. It's not independent of Claude: same family, quite possibly the same blind spots. There's no fallback to another provider, and the harness labels it a same-provider review.

Failover. When I hit a usage limit, the work waits for the reset or runs on usage credits. Nothing fails over to another provider. If Claude has a bad day, so does my harness.

The local lanes. Uncensored work has no home now, and neither does agent work that has to stay on the machine. That's a real gap. It's still smaller than the cost of a lane that slow.

The cleanup

Today the local agent went completely, and so did everything else that wasn't Claude, apart from a few exceptions below.

Grok left the harness at the start of October, but its CLI, its state and an hourly updater were still on my laptop until today. When I started, the local model server was still running with two models loaded.

Six background jobs went with them:

• the local model server
• the nightly model updater
• a finished loop's leftover driver
• three environment and updater jobs for the Codex and Grok CLIs

From the harness code:

• the local-model manager and its evaluator
• the OpenCode request guards, plugin, preflight and launcher
• every OpenCode branch described above
• the Codex and Grok leftovers
• their tests and their docs

In total: 20 commits across five repositories, 310 files changed, 30,383 lines removed and 2,461 added. The harness suite shrank from 762 tests to 503, because the deleted tests covered deleted code; those 503 and the loop controller's 557 are green.

From every project: the AGENTS.md forwarders and the generated .agents/skills adapters. They existed only so other agents could read my Claude instructions. There are no other agents now.

What stayed is just as deliberate:

whisper.cpp went because nothing used it; the tools run other Whisper builds. Local models are fine as components: a bounded job, a clear input, a clear output.

Lessons

If you run a multi-agent or local-agent setup:

• Test on your real work. A clean sprint with hidden tests shows what a model can do. Your everyday tasks show how long it takes. Watch prefill, not just generation speed, because agents read far more than they write.
• A fallback you won't use is not a fallback. If the backup takes hours for what the main agent does in 10 to 30 minutes, waiting for the reset or paying for credits is the better plan.
• Count the plumbing, not just the subscription. Every extra provider drags in adapters, forwarders, guards, branches, tests, docs and background jobs. That shit costs you every day, used or not.
• Uninstall all the way. Removing a provider from the harness doesn't remove it from the disk or from the background jobs. Check both.
• Label second opinions honestly. A same-provider review is still a real review. Just don't sell it as a second company agreeing.
• Use local models as components. Speech, voices, embeddings and re-ranking are fine. The agent that drives the work isn't, not on my laptop, not today.

Next

Much more to come. This was just the initial cleanup of an ever-evolving harness. Something new is coming soon, and this is just the prep.