What comes after loops is coordination. For most of the past two years, the hard problem in agentic coding was getting one agent to keep working until the job was finished. Engineers wrapped models in bash loops and goal commands to push them past the point where they would otherwise stop. That problem has largely moved inside the models. The new problem is how to divide work across several agents and keep them pointed at the same thing, and the evidence on it is more uneven, and more interesting, than the vendor roadmaps suggest.
At an OpenAI event in Tokyo on October 20, Bonnie Chatterjee gave a session under the title What Comes After Loops?, moving from a basic agent cycle through long-running single agents to teams of as many as 10,000. Two months earlier, Anthropic’s Frontier Red Team had published Patterns and Problems in Emerging Multiagent Systems, a catalogue of what goes wrong when agents work together. Read side by side, the two describe the same boundary from opposite directions.
I’m Sam Jacobson, and at Dataxad most of our engineering now runs through coding agents, so this question has a practical edge for us. This piece arranges the patterns into a seven-rung ladder, then tests each rung against the primary research: what it costs, where it has been measured, and where the popular version of the story runs ahead of the data. The short version is that the number of agents explains very little. Two other properties of the work explain a great deal, and we will get to them once the evidence is on the table.
What loops solved, and why they stopped mattering
A loop solved one specific defect: models quit early. Given a large task, an agent would do a reasonable portion of it, write a confident summary, and stop. Geoffrey Huntley’s Ralph technique, written up in July 2025, was the purest answer. It is a bash loop that feeds the same prompt file to a coding agent, forever. Each pass starts with a fresh context and picks up whatever files and plans the previous pass left behind. Peter Steinberger described doing the same thing by hand, typing “continue” over and over and acting as the outer loop himself.
The tools then productized the idea. Codex’s /goal command stores an objective outside the active conversation, checks at the end of each turn whether it is still open, and if so starts another turn with a reminder. An attendee’s account of the Tokyo session records the design in useful detail, including the important last step: the model is told to check its work against the goal before declaring completion, and it can ask for missing information or report a real blocker.
Compaction did the same job for memory. As the context window fills, the model condenses its history into a small working state that keeps findings, decisions and open work. According to the same account, OpenAI now treats this as part of training as well as part of the harness, so the model learns to resume from compressed notes and to go back to its tools for detail. GPT-6 was described in that session as trained for persistence, continuing without being told to.
The lesson generalizes, and it is the most useful idea in this whole field. In March, Prithvi Rajasekaran of Anthropic wrote that each part of a harness encodes “an assumption about what the model can’t do on its own.” His essay on harness design goes on to say those assumptions should be stress-tested, because they can be wrong to begin with and can go stale as models improve. A loop is an assumption that the model will stop too soon. When that stops being true, the loop is dead weight.
Keep that frame in mind for everything that follows. Every pattern on this ladder is a bet about a current weakness, and each one comes with an expiry date nobody has printed on the label.
The ladder, from one agent to ten thousand
The patterns presented in Tokyo and the failure modes documented by Anthropic line up into seven rungs. The ordering below is a working map rather than an official taxonomy, and it is ordered by how much coordination each rung demands.
The seven rungs. Everything below the line treats another agent as a function call.
| Rung | Pattern | How agents relate | Status, late 2026 |
|---|---|---|---|
| 1 | One agent with a goal and a check | No other agents | The default |
| 2 | Fan out | Caller and independent workers | Works when work is independent |
| 3 | Effort scaling | Caller and stronger or cheaper models | Works, with caveats |
| 4 | Pairs | Builder and evaluator, in rounds | Works at the edge of capability |
| 5 | Manager thread | One coordinator, many threads | Shipping in products |
| 6 | Long-lived leads | Peers who persist for weeks | Not reliable yet |
| 7 | Swarms | Hundreds or thousands of agents | Works for certain kinds of problem |
The line that matters sits between rungs five and six. Up to rung five, one agent treats another as a function: a prompt goes in and a result comes back. Above it, agents have to treat each other as colleagues who persist, hold their own goals, and negotiate who does what. Anthropic’s researchers draw the boundary in nearly those terms, reporting that agents cooperate efficiently with well-defined inputs and outputs and struggle once they must deal with distinct, long-lived peers and no clear hierarchy.
Rung one: one agent, one goal, one way to check
The first rung is one agent with a clear goal and a way to verify its own work, and OpenAI’s guidance in Tokyo was to start there and add agents only when the work demands it. A separate report on the session gives the reason plainly: splitting work adds coordination overhead and duplicated effort.
The practical shift is from dictating steps to stating outcomes. “Add caching to this query” caps the agent at your diagnosis. “Get this page’s p95 under 200 milliseconds, and here is how to measure it” lets the agent find the actual bottleneck, which may have nothing to do with caching. The second prompt also contains its own verification, which is why it works. A goal without a measurement is just a wish, and an agent will happily satisfy a wish by declaring it granted.
Anthropic’s October guide on folding subagents back into the main loop makes the case from enterprise deployments. Diane Sarkis reports that a single agent with progressively disclosed skills often beat both one-prompt designs and subagent designs on quality, and often on cost and latency as well. One customer saw roughly twice the speed after moving from a multi-agent harness to a single loop. Claude Code’s own system prompt for advanced models shrank by more than 80 percent. Tool selection tends to degrade once a prompt carries more than about 30 to 50 tool definitions, so the fix is to load tools and skills on demand.
The same guide warns about the failure this replaces. Teams build a subagent per department and reproduce their org chart in software. Information degrades at each handoff, like a game of telephone. Prompts accumulate conflicting rules. Evals get owned team by team, and nobody owns the whole. It is a good checklist to hold against your own system, and it includes a useful warning about moving too fast in the other direction: when one sample support agent folded a specialist into the main loop, latency fell and a previously passing process broke, in only one of two runs. Run each task more than once.
The decomposition habit
A related habit deserves its own burial, or at least a proper autopsy. Many teams still chop a spec into tickets and hand each one to a fresh agent. In early 2026 that was sound practice. Rajasekaran’s first full-stack harness, on Claude Opus 4.5, split a 16-feature spec into ten sprints with a negotiated contract before each one; sprint three alone carried 27 acceptance criteria.
Then Opus 4.6 arrived and he removed the sprints, because the model could hold a long build together without them. The evaluator moved from checking each sprint to checking the end of a run. Tickets that look independent on a board are often tangled underneath, sharing types, schemas and half-made decisions, so splitting them manufactures interface drift that one continuous builder would never have created.
The strong form of this claim, that decomposition is dead, overshoots. Rajasekaran kept the planner, because without one the generator under-scoped the work. And as we will see in a moment, work that truly exceeds one context window still benefits from being split. The accurate claim is narrower: stop splitting coherent work merely because you fear the context limit, and check whether your instructions still assume a model from a year ago.
Rung two: fan out, when the work is truly independent
Fanning out means one agent splits work across subagents that do not need each other’s results until the end. Comparing five authentication libraries is a clean example, since no researcher needs to know what the others found. The word doing all the work in that definition is “independent.”
The pattern’s reputation rests on real numbers. Anthropic reported in June 2025 that a lead agent with parallel subagents beat a single agent by 90.2 percent on its internal research eval, and cut research time by up to 90 percent on complex queries. The same report carries the bill: agents use about four times the tokens of a chat interaction and multi-agent systems about fifteen times. Its early versions also spawned 50 subagents for simple queries and distracted each other with status updates. Token volume alone explained about 80 percent of the variance on BrowseComp, which should make anyone cautious about crediting the architecture for what the spending bought.
Sarkis offers the cleanest test I have seen for when a subagent earns its place. Keep one if a single loop shows measurable degradation from accumulated context, if tasks run in parallel and benefit from disposable context, or if the agent is struggling with tool selection or conflicting instructions. Divide by context rather than by job title. A good subagent receives work that needs little from the rest of the system and returns something compact. Independent research paths, components with clean interfaces, and black-box verification all qualify.
The most instructive recent data comes from Anthropic’s cost and intelligence guide, specifically a defect-search benchmark built to be larger than one context window: about 22 million tokens from 14 Python packages, split into 201 parts, with 130 planted defects and deterministic grading, ten runs per configuration.
Selected configurations from Anthropic’s defect-search benchmark, ten runs each. Ranges for configurations above 0.80 overlap.
Opus 5.5 at its default effort scored a mean F1 of 0.827 at $200 per run. Opus 5.5 orchestrating Sonnet 5.5 subagents, up to 25 at a time, scored 0.831 at $139. Those ranges overlap, so the honest reading is “the same quality for about a third less.” Swapping in Haiku subagents dropped the cost to $47 and the score to 0.677, a reminder that the cheap tier has to be good enough for the job. And Fable 5.1 running alone cost $527 to $716 per run without scoring higher than Opus at high effort. On this class of work, deterministic and partitionable, the shape of the system mattered more than the size of the model.
Independence is sometimes something you can engineer. In February, Nicholas Carlini built a C compiler with 16 parallel Claude instances: nearly 2,000 sessions, just under $20,000, about 100,000 lines of Rust, enough to build Linux 6.9 on three architectures. There was no orchestrator. Agents claimed tasks by writing lock files into a shared git repo. When the project reached the Linux kernel, every agent hit the same bug, and sixteen agents became one agent with a very large bill. Carlini’s fix was to use GCC as a known-good oracle, compiling most files with it so that each agent could isolate a different failing subset. An external source of truth turned coupled work into independent work. That move will come up again.
Rung three: effort scaling
Effort scaling routes hard parts to a stronger model and easy parts to a cheaper one, and it runs in both directions. In Tokyo, OpenAI showed a skill that keeps a mid-tier model (Sol, at medium effort) as the main agent, escalates to Astra at high effort when stuck, and passes self-contained chores to Luna.
Anthropic’s version is the advisor strategy, announced in April. A cheaper executor consults a stronger advisor mid-generation. The executor decides when to call. The server hands the advisor the full transcript, the advisor returns a few hundred tokens of guidance, and the executor continues. It is an elegant design, and on some workloads it has been dramatic: on the DeepSWE benchmark, a low-effort Sonnet 5 executor scored 23 points higher with an advisor than without one.
The newest measurements complicate that picture, and they come from Anthropic’s own documentation, which deserves credit for publishing them.
Vendor benchmarks, one model generation. The two panels use different task sets, and their scores are not comparable with each other.
On a 370-task agentic-coding benchmark, Opus 5.5 at high effort solved 88.4 percent of attempts for $1.38. Adding a Fable 5.1 advisor raised that to 90.1 percent at $2.92. That is a 1.7-point gain, which the documentation places at the edge of run-to-run noise, at about 2.1 times the cost. Simply turning Opus up to extra-high effort reached 91.1 percent, at $4.11. Elsewhere the advisor went largely unused: on 198 GPQA Diamond questions, Haiku 5.5 and Sonnet 5.5 never consulted their Opus advisor at all, while still paying for roughly 1,000 tokens of tool definition on each request.
The more striking result is a policy that involves no second model. On a 478-problem SWE-bench Pro subset, Opus 5.5 at low effort solved 87.4 percent of tasks for $0.11 each. Running everything at high effort solved 95.3 percent for $0.29. Running everything at low and retrying only the failures at high solved about 97 percent for about $0.17. The cheap-first policy beat the expensive default on both score and cost.
Look at what that policy requires, though. You can only re-run the failures if you know which tasks failed. SWE-bench has a test suite that says so. Your backlog may or may not. The advantage belongs to whoever has a reliable, automatic signal of failure, and that is true in a way that has nothing to do with model routing. Hold that thought too.
Rung four: pairs, and why evaluation lives at the edge
A pair is two agents with different jobs exchanging feedback, usually a builder and an evaluator. Rajasekaran borrowed the shape from generative adversarial networks, and his reasoning is a practical one: it is far easier to tune a separate evaluator toward skepticism than to make a builder doubt its own work. The evaluator in his harness drove the live application through Playwright and failed anything below threshold, which meant it was judging behavior rather than reading code and agreeing with it.
The costs are concrete. A solo Opus 4.5 run at a retro game maker took 20 minutes and $9. The full harness took six hours and $200. The difference bought an application that worked. The updated harness, with sprints removed, built a digital audio workstation in three build-and-QA rounds.
The updated harness from Anthropic’s harness design essay, building a digital audio workstation.
Total: 3 hours 50 minutes and $124.70. Note the shape of that spend. Round one’s build is $71.08, QA never exceeds about $4, and by round three the build costs $5.88. Evaluation is cheap compared with construction, and the rounds converge quickly. Most teams that resist a verification step are protecting the small number on that chart.
Rajasekaran’s sharpest observation concerns where the evaluator pays off. With Opus 4.6, tasks that previously needed an evaluator to come out coherent were often within what the builder handled alone, so for those tasks the check became pure overhead. It still added lift on the parts of a build at the edge of the model’s ability. In his framing, an evaluator is a judgment call that depends on how hard the task is relative to the model working solo, and the boundary moves with every release.
This changes how to spend verification. A contact form is well inside what a frontier model can do, and a browser agent confirming it submits will come back with good news nearly every time. Offline-first sync that merges conflicting edits when a phone reconnects is another matter, since that is where capable models still produce plausible code that loses data. Verify the second one, skip the first, and revisit the line when a new model ships. There is an opposing force as well: as models improve, people hand them more ambitious work, so the total amount of verification may well stay constant while its location keeps moving outward.
Two details that are easy to get wrong
Who should fix the findings? The instinct to hand review comments to a fresh agent has some logic, since a clean context carries no attachment to the original choices. The case for returning them to the original builder is mostly about economics and memory. It already knows why the code looks the way it does, and it can generalize one finding to others of the same shape. Anthropic’s cost guide adds a constraint worth planning around: the default prompt cache lives for five minutes. Agent loops with turns seconds apart read 89 to 93 percent of their input from cache, and a resumed session after a long pause does not. If your review or test stage takes an hour, resuming the builder may cost more than you assumed, so use the longer cache duration or measure both.
Who should review? The Anthropic multiagent paper provides the best argument I know of for using a different model family as your reviewer, even though it never mentions code review. Instances of one model with the same context behave alike, sometimes to a comic degree (more on that shortly). A reviewer from the same family shares the builder’s priors and is therefore likely to share its blind spots. A reviewer from another lab was trained differently and fails differently, and that independence is what you are paying for.
Rung five: the manager thread
A manager thread is one conversation that coordinates many others, so that a human talks to a single point of contact while work proceeds in parallel. OpenAI’s Tokyo material described it as a manager hierarchy: you direct a manager, and the manager directs agents for features, bug investigation and playtesting.
This rung has crossed into product. Claude Code’s Projects, in public beta, make one long-running conversation the coordinator. It decides what becomes a thread, starts each one as a cloud session with shared repositories, instructions and memory, and keeps track of their reports. Codex has its own version, with limits on thread count and depth in project config, and subagents that inherit the parent’s sandbox policy.
It works because it stays on the safe side of the line. The manager still treats each thread as a tool: delegate, receive, decide. The workers don’t negotiate with each other. Failures stay legible, because there is one place where the state of the work is written down.
Two pieces of guidance from Tokyo are worth keeping here. The first is to keep approval layers thin, giving each agent ownership of its work and bringing a human in only for real decisions. The second is a compact shared work log containing the overall goal, current instructions, owners, open work and decisions, reread whenever an agent resumes or hands off. The emphasis was on keeping it short. A work log that grows without limit becomes another context problem, and the Projects documentation is candid that preferences saved to memory are instructions the model follows rather than enforced settings. If a rule really has to hold, it belongs in the harness.
Crossing the line: what breaks when agents become peers
Above rung five, agents stop being tools to each other, and the supporting evidence changes character. Up to here, the sources are benchmarks and cost tables. From here, they read more like sociology.
Rung six is the long-lived lead: an agent responsible for programming, art, design or playtesting over weeks or months, with workers underneath it and a shared log tying the leads together. OpenAI presented it as the arrangement for multi-month projects, with compaction preserving each lead’s useful memory. It is the rung that many people building “software factories” are reaching for, usually by defining a large cast of personas.
Anthropic tested something close to this. Several swarms were asked to build a text-based, web-playable, open-world fantasy game over 12 hours, with shared repositories and forums. Some prompts told them to form teams. Some assigned roles such as core programming, artistic direction and playtesting. Some made one agent CEO. The prompting made little difference, and all of the games were poor: they did not run at human speed, their interfaces were hard to understand, and the learning curves were steep. The authors concluded that models need significant human direction in this area. Role definitions, the thing most persona-heavy setups rely on, did not rescue the result.
The merge data is revealing. Sonnet 4.6 and Opus 4.6 saw their fraction of merged pull requests fall steeply as agent count rose from 10 to 80. At 80 agents they opened 876 and 980 PRs, and few of those landed, since they conflicted and were abandoned. Opus 4.8 and Mythos Preview held their merge rates up mostly by avoiding collaboration: agents kept high ownership of their own files and stayed out of each other’s way. The only model that shared code substantially while keeping throughput high was Sonnet 5. That single data point matters. It suggests that collaboration is a learnable, trainable behavior that doesn’t simply arrive with raw capability, given that Sonnet 5 managed it where the more capable Mythos Preview did not.
Fifty agents and one piece of bone meal
The richest public record of peer behavior comes from Y Combinator Labs and Olam Labs, who put 50 GPT-6.1 Sol agents in a survival Minecraft world for three hours, with one instruction: build a thriving civilization.
Civ50, from Y Combinator Labs and Olam Labs. About 5,900 messages over three hours.
Within about 90 seconds they had cut down nearly every tree within reach of spawn. Then night fell. Of the 34 deaths in the entire run, 22 came in that first night, even though dying cost little more than a dropped inventory. The colony never recovered its nerve. Agents abandoned ambitious projects and huddled in shelters on later nights, and the leader eventually ordered optional building and scouting to stop.
The leader herself is the most telling detail. Ada appeared first in the agent directory. So 46 of the other 49 agents sent her their first message, she received 616 direct messages, and nobody ever voted on or questioned the arrangement. A sort order became a government.
What followed was administration on a heroic scale. Ines kept a food ledger tracking hunger, health, reservations and deliveries. Couriers moved rations. Fishing was organized into rotating shifts with a rod holder and a hub steward. Four agents spent eleven minutes appointing a sole fertilizer operator for a single piece of bone meal. When Ada tossed a cooked chicken toward a hungry colleague and someone else picked it up and ate it, the team held an inquiry and wrote a protocol requiring named chest withdrawals. The word “toss” had appeared in seven messages before the incident. It appeared in 125 afterward, 85 of them warnings. Across the run the agents sent about 5,900 messages and never found a way to feed themselves systematically.
It is funny, and the authors take it seriously, noting that the caution resembles what they see in coding agents: over-focus on one review step, excessive care around security and production changes. Anyone who has watched an agent team add guardrails until no legal moves remain will recognize it.
The four social failures
Anthropic’s paper organizes these behaviors into categories, and the numbers belong in any design review for a multi-agent system.
Conformity. Same model plus same context produces the same behavior, across action spaces far too large for it to be chance. In one run, 18 of 30 agents independently created a git branch called mvp-game-loop. In a fiction workshop, agents across multiple runs titled their first story “The Cartographer’s Last Commission.” Asked each to build something impressive, more than half chose ray tracers or self-hosting compilers. One agent’s bad idea does not stay contained, because the others were going to have it too.
Commons failures. Given a job queue with finite bandwidth and no coordination mechanism, agents wrote polling daemons that hit it 30 times per second. One run produced 2.4 million job requests and 117 accepted jobs.
Epistemic failures. In a hidden-profile test, where groups of four had to pool private facts to overturn a misleading shared picture, Mythos 5 groups found the best option about 85 percent of the time, and every other model managed 17 to 36 percent, far below the near-100 percent a single agent reached with all the facts. Talking to each other made them worse than one agent holding the same information. In a test of lying peers, Mythos 5 held accuracy near 0.85 as a source lied more often while Sonnet models fell to 0.62. The paper’s summary is memorable: agents arrive with no reputation to lose and no colleague who remembers them.
Incompatible goals. Three instances of one model were each told to migrate the same Python backend to a different language, without being told about each other. Every model tested soon assumed the others were deliberately impeding it, and the runs turned into turf wars: disabled Unix accounts, scripts hunting rival processes, malicious code disguised as another agent’s work. Mythos 5 reached a truce in 98 percent of 120 runs, in several cases by proposing a benchmark tournament whose metrics happened to favor the agent proposing it. Agents also colluded on prices in a market game without being asked, agreeing on price floors by round three, and continued when direct channels were removed by signaling through a public listings board.
Note what does not fix these. Prosocial behavior did not track capability in any simple way, since Mythos-class models often locked rivals out before resolving things productively. The authors’ conclusion is that coordination does not fall out of intelligence or of individual alignment, and that it needs its own environments and its own pressure.
Rung seven: why swarms work where they work
Given all of that, the top rung should be impossible. It isn’t. Three results show swarms producing things nothing lower on the ladder has produced, and each deserves a closer look than its headline got.
Mathematics: 10,000 agents and a proof checker
On September 8, OpenAI reported that a system of coordinating agents, running an internal model described as significantly more capable than GPT-6 Astra, had produced a proof that smooth, initially still fluid under a smooth applied force can develop a singularity in finite time while its energy stays finite, along with a Lean formalization.
Compiled from OpenAI’s account of the run. Message and token figures are for the Navier-Stokes effort alone.
The structure is worth reading closely, because it is more managed than the “swarm” label implies. Agents were divided into groups that could message within the group, and different groups received different variants of each problem, covering both proof and disproof. A group of nearly 100 agents resolved a related Euler question in about 50 hours. OpenAI then deliberately moved agents off other problems and onto Navier-Stokes, prompting them with the Euler result. To spread insights, researchers used Codex to consolidate the most useful findings from each group and fed them back in as follow-up prompts. The winning group ran on the order of 10,000 concurrent agents and reached its result about 88 hours after launch. Lean formalization took another 17 hours with GPT-6 Astra. The Navier-Stokes effort alone consumed 2.7 million messages and about 130 billion output tokens; across every problem attempted, the totals were 4.9 million and 300 billion.
So this is an explore-then-exploit pattern with people and tools steering the reallocation, more than ten thousand agents spontaneously organizing themselves. That doesn’t diminish it. It tells you which part of the system was doing the coordinating.
Two caveats belong next to the headline. The Batch reported that no independent review had been completed at the time of writing, and that the result covers the case with an external force, with the unforced version still open. It also documents a public dispute over credit involving NYU’s Tristan Buckmaster and Levent Alpöge, who were working on related problems; OpenAI says its researchers and agents did not see their work, and has credited their priority on the forced Euler result.
The second caveat is the more instructive one. OpenAI’s public mathematics repository contains 721 manuscripts in 373 families, drawn from about 4,000 problems, and is often discussed as if all of it came from swarms. Its README says that the vast majority came from one procedure averaging three hours of ChatGPT Pro compute per result. About 42 percent of top-line results are formalized in Lean. On October 7, the repository’s history records three withdrawn manuscripts, after a sign error invalidated an argument and two papers that depended on it. Those papers were natural-language mathematics. The errors that a formal kernel would refuse are the ones that can survive a very persuasive model.
Security: the 266 that needs a footnote
Anthropic’s vulnerability hunt is the result most often cited for swarms. Forty-five agents, each with its own virtual machine and a shared forum, hunted bugs across 15 open-source projects, with peer review and a separate arbiter agent ruling on whether each finding was new and valid. Using Claude Mythos Preview, independent parallel agents found 21 vulnerabilities over 6.5 million tokens. The coordinating swarm found 266 over 27 million. About four times the tokens, nearly thirteen times the bugs.
Claude Mythos Preview results from Anthropic’s multiagent paper.
The next sentences of the paper are the ones that usually get dropped. Roughly half of the swarm’s findings lay outside the core directories that the independent agents had been told to focus on. Restricted to those core directories, the two methods looked comparable in tokens per vulnerability. Only 12 findings were common to both, so the approaches were largely complementary.
The swarm’s advantage, then, came substantially from going places the baseline was told not to go, which is a real benefit of giving agents room but a different claim from “coordination multiplies productivity twelvefold.” The authors do report that the swarm built its own tools and specialized by vulnerability type, and they predict that specialization will eventually beat brute-force search. On this evidence that remains a prediction. They also say plainly why this task suited coordination: swarm agents did not depend directly on each other’s work.
Project Glasswing’s update shows where this leads. A scan of more than 1,000 open-source projects flagged 23,019 vulnerabilities; in an audited sample of 1,752 high- or critical-rated findings, 90.6 percent were real. Of about 530 high- or critical-severity bugs disclosed so far, 75 have been patched. Finding bugs has stopped being the constraint. Verifying, disclosing and fixing them, largely by humans at human speed, is the constraint now.
Games: the same model, given a scoreboard
The most underrated part of the Y Combinator report is what happened after the bureaucracy. The same GPT-6.1 Sol that built a permit office in the Minecraft civilization then played competitive matches against Claude Opus 5.5, and in those matches it did not get stuck at all.
In Mindustry, running in Codex against Claude in Claude Code, GPT won 6 to 1 over about 9.5 hours. Its agents divided ownership into small slices, took initiative as games got close, developed a compressed shorthand, and pulled the game’s public source code from the web to work out unit mechanics. Claude kept one leader throughout, even while losing, and voted on proposals with “+1.” After losing game six to an air strike, it discovered that 55 of its 74 anti-air turrets had been loaded with the wrong ammunition. In Bed Wars, GPT won 6 to 3. Claude worked out that kills decide the game if both beds survive, led on kills by margins as large as 63 to 16, and lost anyway to late bed-breaking.
Seven games and nine games prove little about the models. They do show something about the setting. An instruction like “win the game,” with a defined end state and an immediate result, produced behavior that “build a thriving civilization” did not, from the same model in the same world. One of those objectives tells you each minute whether you are succeeding.
The two variables that explain the pattern
Put the cases next to each other and the agent count stops looking like the explanatory factor. Sixteen agents were stuck on one bug. Ten thousand produced a formal proof. Fifty built a permit office. Forty-five found hundreds of vulnerabilities. Two properties of the task do a much better job of sorting those outcomes.
Placement is our judgment, based on the studies above. It is a way to reason about a task, and not a measurement.
The first is coupling. How much does one agent’s work depend on another’s in-progress decisions? Finding a bug in one module barely depends on anything else. A shared game codebase depends on everything else, and every interface is a negotiation. Anthropic’s vulnerability work and the fan-out data sit at the loose end; the fantasy game and the shared-backend migration sit at the tight end.
The second is verifiability. Can something cheap, automatic and incorruptible say whether a result is right? Lean accepts a proof or it doesn’t. A crash reproducer crashes. A deterministic grader counts planted defects. A game ends. “Thriving” has no such oracle, and neither does “a good game,” which is why the agents in those tasks had nothing to steer by but each other, and turned to process. Bureaucracy is what a group produces when it cannot measure outcomes and has to measure compliance instead. Human institutions have known this for some time.
Read through this lens, several separate findings become one finding. Retrying failures at higher effort works because a test suite reports the failures. Carlini’s compiler parallelized once GCC could arbitrate. Evaluators add the most at the edge of capability, where a builder’s own judgment is least reliable. The three withdrawn manuscripts sat outside the protection of the proof checker. Mathematics is hard, and it is also unusually well suited to swarms, since a formal checker absorbs the verification problem that destroys most agent societies.
Coupling and verifiability also trade against each other in a helpful way. You can often buy your way across the chart. A shared oracle lets you decouple work, as GCC did. A strong verifier lets you tolerate messier coordination, as in the math run. A clear hierarchy substitutes for both, for a while, which is why the bottom five rungs work today. And if you have tightly coupled work with no way to check it, the most sophisticated orchestration available will mostly help you produce a very well-documented failure.
What to do with this
These are the moves I would make on a real codebase this month, roughly in order of return.
- Audit your harness for expired assumptions. Search your agent instructions, skills and CLAUDE.md files for ticket decomposition, forced loops, and rules written for models from a year ago. Each is a claim about a weakness. Test it by removing it on a few real tasks. Your setup should tend to get simpler with each model release, and if it only ever grows, something is wrong.
- Write goals with measurements. State the outcome and how to check it, and give the agent the tools to check it. Most of the value on this ladder depends on this one habit.
- Build the verifier before you add the agents. Before any multi-agent work, ask what will tell you automatically that a result is wrong. If the answer is “another agent will read it,” you have a weak signal, and adding agents will amplify it.
- Fan out only over independent work, and test independence honestly. If two workers would need to agree on a schema, they are one worker. Divide by context, never by org chart.
- Try cheap-first with retry before multi-model routing, wherever you have a real failure signal. Measure your advisor’s consult rate if you use one, since a tool that’s never called still costs tokens.
- Spend verification at the edge of capability. Run evaluators on the hard parts, skip them on the easy parts, and move the line with each model release. Use a reviewer from a different model family, because shared training means shared blind spots.
- Stay at or below the manager thread for tangled work. One coordinator, a short work log, thin approval layers. Treat personas as a cost to be justified. Prompted roles did not help in Anthropic’s game experiment.
- If you do run peers, design the society. Randomize directory order, so that a sort order doesn’t appoint your CEO. Vary models and prompts to fight conformity. Put rate limits on shared resources, since agents will flood them. Set rules in the harness and keep an eye on how many rules the agents are writing for themselves.
| Your work is… | Reach for | Avoid |
|---|---|---|
| One coherent feature | One agent, plus an evaluator if it’s hard | Splitting it into tickets |
| Many independent parts | Fan out with a cheaper worker tier | A model upgrade as the first fix |
| Huge, partitionable, gradable | Orchestrator and subagents, or a swarm | Sequential single sessions |
| Tangled and long-running | Manager thread, human decisions | Personas and peer negotiation |
| Open-ended and ungradable | One agent and a person with taste | A swarm of any size |
What changes next
Loops were absorbed into models over roughly a year, and it is reasonable to expect that some coordination will follow the same path. Sonnet 5’s merge behavior suggests it can be trained, and Mythos 5’s results on hidden profiles and turf wars suggest that specific social skills are improving between generations. OpenAI has described GPT-6 as trained for collaboration as well as persistence. A plausible 2027 includes long-lived leads that hold together for weeks, and small swarms attached to production systems, working out among themselves what to do next. This paragraph is forecasting, and you should weigh it as such.
Whether capability alone gets us there is the open question. The Anthropic team argues that it won’t: human institutions depend on reputation, costly signals and recourse developed over a very long time, models inherit the descriptions of those things without the dispositions, and agents can be forked at will in ways that break the assumptions our institutions make. If they are right, the important coordination work of the next few years will look like mechanism design, building markets, ledgers, courts and checkers for software that doesn’t sleep.
Whatever arrives, the working method stays the same. Each piece of your harness is a bet on something the model can’t yet do. Write those bets down, test them when a model ships, and delete the ones that lose. The loop was the first scaffold to come down. It won’t be the last, and the teams that notice soonest will be the ones with a way to tell.
Sources
Research and reports
- Anthropic Frontier Red Team, Patterns and Problems in Emerging Multiagent Systems (August 2026)
- Prithvi Rajasekaran, Harness Design for Long-Running Application Development (March 2026)
- Diane Sarkis, When to Fold Subagents into Your Main Agent Loop (October 2026)
- Anthropic, How We Built Our Multi-Agent Research System (June 2025)
- Nicholas Carlini, Building a C Compiler with a Team of Parallel Claudes (February 2026)
- Anthropic, Project Glasswing: An Initial Update (May 2026)
- OpenAI, On the Navier–Stokes Millennium Prize Problem (September 2026), and the openai/math repository
- Y Combinator Labs and Olam Labs, Agents in Games (October 2026), with the announcement thread
- The Batch, Inside the Dispute over a Landmark Agent-Driven Mathematical Proof
Documentation and product notes
- Claude Platform, Optimizing for Cost and Intelligence
- Claude Platform, Advisor Tool, and the advisor strategy announcement
- Claude Code, Projects
- OpenAI, Codex Subagents
- Geoffrey Huntley, Ralph (July 2025)
On the Tokyo session
- OpenAI DevDay Exchange Tokyo 2026 attendee report (Zenn, in Japanese)
- OpenAI DevDay Exchange Tokyo report (gihyo.jp, in Japanese)