Anthropic can reportedly run Claude on a research task for about $4 an hour, against roughly $150 an hour for a human researcher, and outperform them. Anthropic also set multiple AI agents loose on the same task and watched them start a turf war.
Both of those things are true at once, and if you build bots for a living, that pairing should feel deeply familiar. The individual unit is cheap and startlingly capable. The system you assemble out of those units is a coordination problem wearing a trench coat.
An Anthropic researcher recently gave the public a peek at self-improving AI, and TechCrunch covered it. That’s the headline everybody’s chasing. I want to talk about what it means for the people actually wiring these things together.
Self-improvement is a loop, not a personality trait
When I hear “self-improving AI,” my brain doesn’t go to science fiction. It goes to the architecture diagram. A self-improving system needs three things that have nothing to do with intelligence and everything to do with plumbing:
- A signal. Something that tells the system whether the last attempt was better or worse. If you can’t measure it, the loop can’t close.
- A memory. Somewhere to keep what worked so the next run starts ahead of the last one.
- A gate. A checkpoint that decides whether a proposed change actually ships.
Miss any one of those and you don’t have self-improvement, you have a model rerunning itself with extra steps and a bigger bill.
The cost figure is what makes the loop interesting. At $150 an hour, you run one attempt and you’d better like it. At $4 an hour, you can run thirty attempts and pick the best one, and the economics of iteration flip entirely. Search becomes affordable. That’s the actual mechanism behind a lot of what gets labeled self-improvement: not a model waking up smarter, but a model getting enough cheap swings at the problem that the good outcome shows up somewhere in the distribution.
Which puts all the pressure on your evaluator. If you can’t tell attempt seven from attempt twenty-three, cheap iteration just gets you thirty mediocre answers faster.
The turf war is the real lesson
Anthropic pointing several agents at one task and getting territorial conflict is, to me, the most useful thing in this news cycle. It’s the failure mode I hit constantly in multi-agent setups, and it’s not a bug in the models. It’s a bug in the org chart.
Agents with overlapping mandates and no arbitration will step on each other. One rewrites what another just wrote. Two of them decide they own the same file. A third helpfully undoes a fix because it looks like a regression from where it’s standing. None of them are wrong given what they can see, which is exactly the problem.
Things that have helped me:
- Ownership boundaries. One agent owns one surface. If two agents can write the same resource, you need a lock or a referee.
- An explicit coordinator. Not another peer, a supervisor whose only job is assignment and conflict resolution.
- Append-only work logs. Shared mutable state is where turf wars breed. Let agents write proposals, let one process merge them.
- Fewer agents. Genuinely. Most tasks I’ve split across four agents ran better on one with better tooling.
Parallel agents look like a speedup and behave like a distributed systems problem. Because they are one.
Memory is the boring prerequisite
Alongside all this, Claude Cowork now remembers what you told the app in chat. That sounds like a small quality-of-life fix, and as a product feature it is. As infrastructure, it’s the piece the whole self-improvement story rests on.
An agent that forgets between sessions cannot get better. It can only be good or bad at a fixed skill level, restarting from zero forever. Persistent context is the difference between a tool that performs and a system that accumulates. If you’re building bots right now and you’ve been treating memory as a nice-to-have, that’s the thing to fix before you chase anything fancier.
Nobody has a moat here
New data suggests OpenAI is gaining on Anthropic with business users. I mention it because it’s a useful antidote to reading any single lab’s research preview as a permanent lead. The capability that gets demoed this quarter tends to be table stakes a few quarters later, available through whichever API you already pay for.
So the durable work isn’t picking the winner. It’s building the loop: the measurement, the memory, the gate, the coordination rules. Those are yours. They keep working when you swap the model underneath, and they’re the reason cheap iteration turns into an actual result instead of an actual invoice.
Start with the evaluator. Everything else is downstream of knowing whether you’re getting better.
🕒 Published: