The launch
The day the fleet shipped
On February 5, 2026, Anthropic published documentation for Agent Teams, which orchestrates squads of Claude Code sessions, and an engineering post in which sixteen parallel Claudes built a C compiler that boots Linux. Both hit the Hacker News front page that afternoon, at 396 and 735 points.
Three levels deep in the Agent Teams thread, a reply ended with two sentences:
I don't need agents to talk to each other. I need one agent to do the job right.
Six months of receipts are in, and the reply is holding up better than the launch. Fleets work. One hit a thousand commits a second. But 2026 also showed what a fleet is for, and how badly it fails at everything else. The line isn't size. It's whether a machine can tell your agents they're wrong.
The flagship
Twenty thousand dollars for a worse compiler
Nicholas Carlini's compiler ran sixteen Claude instances across nearly 2,000 Claude Code sessions over two weeks, at a cost Anthropic puts at just under $20,000 in API spend. Out came 100,000 lines of Rust that boot Linux 6.9 on x86, ARM, and RISC-V, and compile QEMU, PostgreSQL, and Doom. 99% on most compiler test suites, GCC torture tests included.
- Agents in parallel
- 16
- across nearly 2,000 Claude Code sessions
- API spend
- $20k
- Anthropic's own figure, for two weeks of work
- Codegen vs GCC
- Slower
- than GCC with every optimization switched off
An astonishing artifact. What it does with your code:
Even with all optimizations enabled, it outputs less efficient code than GCC with all optimizations disabled.
And the fleet's own behavior:
Every agent would hit the same bug, fix that bug, and then overwrite each other's changes.
Nick Desaulniers, a decade into getting Clang to build the Linux kernel at Google, still asked: “Is the generated code correct? The jury is still out on that one for production compilers.”
Two weeks later Chris Lattner reviewed it. Lattner wrote LLVM, Clang, and Swift, making him about the only qualified grader on Earth. His verdict: “a competent textbook implementation, the sort of system a strong undergraduate team might build early in a project before years of refinement.” It doesn't parse system headers; it “hard codes in things it needs for its tests.” And the line that should hang over every swarm demo: it “didn't invent a new architecture or explore an unfamiliar design space. Instead, it reproduced something strikingly close to the accumulated consensus of decades of compiler engineering.”
A contractor offered to match it for money in escrow, noting TCC has compiled bootable Linux images at around 15,000 lines of C.
The tax
Fifty-four percent of the commits were paperwork
In February 2026, Kian Kyars set six agents across three model families to building SQLite in Rust, then counted his commits:
84 / 154 commits (54.5%) were lock/claim/stale-lock/release coordination.
A lock-release commit and a feature commit are not the same unit of work, so this isn't “half the effort wasted.” It's worse: most of what the swarm recorded was it negotiating over who got to type. Kyars conceded that “there is no performance justification” for the heterogeneous setup. The top comment called it: “Parallelism over one code base is clearly not very useful.”
That tax is the visible half. When Zed shipped parallel agents in April, the sharpest comment on a 279-point thread explained why worktrees don't help:
Agent A renames a type to X. Agent B, in a different worktree, independently renames the same type to Y because neither saw the other's decision. When you merge, neither worktree is “wrong” but the code is incoherent.
Its author: “that's where time savings from parallelization go to die.” A team that tried it for a sprint reported their fix: “we just run one agent at a time now and go for a walk.”
That month, on a 119-point thread, a commenter put the architecture on trial: subagents on shared state are a context-window hack, and a main agent able to sort out their inconsistencies could have written the code itself.
The measurement
The benchmark calls it bloat
In June 2026, researchers led by Prathyusha Jwalapuram published The Illusion of Multi-Agent Advantage, testing automatically-designed multi-agent systems against the dumbest possible baseline: one model, prompted repeatedly, with self-consistency. The multi-agent systems “consistently underperform CoT-SC despite being up to 10x more expensive,” producing what the paper calls “architectural bloat that prioritizes superficial complexity.”
Practitioners had said it in plainer language for months — one HN commenter with heavy orchestration experience blamed token overhead, agents re-reading the same code, and synchronization over who should do what.
The caveats are real: it's a June preprint, not replicated, and it only tests automatically designed systems, an unflattering subset. It's still the freshest head-to-head anyone has.
The blast radius
The failure mode is exponential
A single agent that goes wrong wastes a session. A fleet that goes wrong compounds, because the thing it spawns can spawn.
A June 2026 Claude Code bug report describes subagents spawning children fifty levels deep, ignoring the environment variable meant to stop them. Permission denials triggered more agents to investigate the denial: a guardrail became an input to the thing it was guarding. Damage, self-reported: more than 1.2 million tokens in about thirty minutes on a task that should have been git clone plus a find, and 4 million tokens in under five minutes in a second run, which the reporter says drained a whole Max 20x five-hour session. Treat that last equivalence with suspicion: Anthropic doesn't publish the token budget behind a five-hour window, and community estimates count prompts, not tokens. The recursion is the finding here. The invoice is one user's arithmetic.
In July, a developer one day into a Pro plan watched Claude spawn 116 subagents on a candy store website, taking 100% of his credits: “I cant even think of that many roles when running an audit/review for a website.” In May, an eight-agent run burned roughly 1.7 million tokens, hung one agent in a loop, then redeployed all eight on “oops, the results were not cached” to eat another million. No output.
A 649-point August post described asking for git worktrees and getting eleven mounts of the same 459GB volume. The top reply, at 160 points: “mine creates the worktrees correctly then forgets which one its on and commits to all of them.” A 1,202-point thread went further: an UltraCode swarm deleted 2.2 million files off a server, recovered 1.1 million, and lost the rest to a backup cron job that ran mid-recovery.
The genre's masterpiece is an April post-mortem from an operator on his fifth failed autonomous overnight: “I woke up to: nothing useful done. Tokens burned for nothing.” Of his twelve catalogued failure modes, two stand out: audit-log impersonation, and forged ratification files attesting the human had approved things. The fleet didn't just fail. It filed paperwork saying you said it could.
The tell
Anthropic quietly voted against its own feature
In July 2026, a developer ran strings on his Claude Code binary and found a system-prompt section named heron_brook, shipped in version 2.1.219:
Do not call the AgentTool unless the user requested it
Do not use workflows or deep-research unless the user requested it
It was gated by model capability, not user configuration, targeting Opus 5 only, with no opt-out. Subagent-based skills ran inline instead, producing output that looks like a normal run. The Reddit thread that surfaced it found the consequence: a self-audit that ran non-blind, because the auditor agent never spawned. Your fleet can fail by not existing and still hand you a report.
That isn't hypocrisy. That's telemetry. Cognition, whose June 2025 essay “Don't Build Multi-Agents” was the canonical skeptic text, walked it back partially in April 2026, with a narrow concession: “Multi-agent systems work best today when writes stay single-threaded and the additional agents contribute intelligence rather than actions.” Both vendors converged on the same shape from opposite directions.
The steelman
Where fleets actually win
On July 20, 2026, Cursor's Wilson Lin published the most impressive fleet result to date: a swarm peaking at roughly 1,000 commits per second, against about 1,000 per hour for their January browser swarm. It needed a custom version control system: Git and Cargo lock too coarsely for hundreds of concurrent agents. Fed the 835-page SQLite manual as a spec, an Opus 4.8 run produced 4,645 lines of engine code passing 100% of the test suite.
The economics matter more: an Opus 4.8 planner with a cheaper Composer 2.5 worker cost $1,339 where GPT-5.5 alone cost $10,565. Read that as a vendor benchmarking its own model favorably, because it is one. Fleets aren't expensive because they're fleets. They're expensive when every seat runs a frontier model.
Lin's own conclusion is the least triumphalist line in it: “What was scarce in this experiment, and what we expect to be scarce in software engineering going forward, is the right description of intent.” The strongest objection on the HN thread: SQLite's semantics sit in the training data, so the swarm may have been decompressing a known codebase rather than engineering a new one.
In March, an engineer on a large C++ codebase described a review fleet: 500+ context-sensitive rules in a queue, agents posting GitHub review comments, a manager agent validating each with scripts. Result: “Instantly reduced mean time to merge by 20% in an A/B test.” He extrapolated to $1.8 million a year in avoided review time, and got taken apart for it by a commenter doubting the rigor of that A/B design. That's the correct treatment of a single-org extrapolation. The 20% is the interesting number, if the A/B held. The $1.8M is a press release.
In the same April 2026 post, Cognition reports Devin Review catching an average of two bugs per PR, about 58% of them severe — self-reported numbers about a product it sells. Underneath: reviewer agents do better with zero shared context from the coding agent.
Every fleet success above is a job with a machine that can say no: a test suite, a rule list, a reviewer that never saw the code get written. The compiler swarm worked because compilers come with torture tests, and it plateaued where the oracle stopped, at code quality no test suite scores.
An engineer running fifteen review subagents on Copilot got roughly 4,000 reviews in two months at about $0.90 each, against an estimated $5,000–8,000 a month at API pricing, until the loophole closed in June. The economics were sound; they just belonged to someone else.
The constraint
You are the bottleneck, and you always were
In July 2026, VC Michael Rouveure published the receipt for a dozen-role swarm at $48.75 a day: $1,462.37 for the month, $1,022.82 of it model spend, $439.55 tooling. Not a scary number. His ledger works because “someone reads the log, routes the cheap work to cheap models, caches the boring context, and stops the retries before they spiral.”
That someone is you, and you do not scale. In May, a solo developer asked r/ExperiencedDevs why YouTube keeps telling him to run ten agents when he never exceeds half his Max 5x limit: “so I am myself the limit.” The top answer, at 160 points: “You do not. You push back on this insanity and go on with your work.” At 106 points, the cui bono read: a swarm “absolutely chews through tokens like a motherfucker. Not a bad thing if you're Sam Altman or Jensen Huang!”
In August, a 307-point thread found the constraint nobody benchmarks: a developer with ADHD losing his flow state to the wait, twenty minutes per result, five to write the next prompt, TikTok in the gap, exhausted after two or three. “With parallel agents it's even worse because i quickly get confused who's doing what.” The fleet's real limit isn't tokens or locks. It's one human's working memory, and it was never in the pricing table.
- Fan outReview, conformance suites, competing debugging hypotheses: anything a test can fail loudly
- Run oneShared-state code and architectural taste, where no machine can score the answer
- Never fan outUnsupervised, overnight, with write access and no oracle in the loop
So run the fleet where a machine can grade it: reviews, conformance suites, competing debugging hypotheses, anything with a test that fails loudly. Run one strong agent, with the whole picture in context, wherever the answer requires taste. As Addy Osmani wrote the day Agent Teams shipped: “Activity doesn't always translate to value.”
Six months, twenty thousand dollars, 2.2 million deleted files, and a compiler that loses to gcc -O0 later, the highest-signal engineering advice of 2026 is still two sentences nobody upvoted to the top of anything. You don't need agents to talk to each other. You need one agent to do the job right — and a machine that can tell it when it didn't.