Agent teams for $155 instead of $510: Cohere finds where delegation actually pays off

Agents have moved into production

Over the past year, teams of coding agents have graduated from impressive demos to real industrial projects. Sixteen Claude agents wrote a 100,000-line C compiler capable of building the Linux kernel, burning roughly 2,000 sessions and $20,000 in API costs. Cursor's team launched hundreds of agents that jointly wrote a web browser exceeding a million lines of code in a week. The Bun project ported its codebase from Zig to Rust in 11 days using 64 Claude agents working in parallel.

Each of these projects shipped working code, but they differed in how they were organized: the compiler was built by equal-status agents with no orchestrator, grabbing tasks via lock files; Cursor used a hierarchy — planners recursively broke work into subtasks for hundreds of workers; Bun assigned fixed roles: one implementer, two reviewing critics, and one fixer per job.

Comparing these projects head-to-head wouldn't say much about which decisions actually mattered or what they cost. Factory published research on its own three-role system (orchestrator → implementer → validator in a loop): on one task (restoring the GDAL library), its team doubled a single agent's result — but cost 14 times more and took 13 times longer.

Where you delegate matters more than how many agents you use

Cohere built a controlled testbed based on mini-SWE-agent: each agent works through a bash interface in a shared workspace, the leader distributes tasks via a delegate_agent tool, and workers only see their own subtask. The researchers tested five variables:

1. Where the leader uses workers: a minimal prompt simply tells the team to get on with it; a structured (P-I-V) prompt adds explicit stages — planning, implementation, verification. 2. How the leader waits: synchronous (waits for everyone to report back) or asynchronous (keeps working itself, checking in on updates as needed). 3. Which models fill which roles: homogeneous teams (everyone on Sol) versus heterogeneous ones (leader on Sol, workers on Luna). 4. Team size: the leader decides how many workers are needed, or the size is fixed at 2, 4, 8, or 16. 5. Communication: routed through the leader (default) or directly between agents.

Tests ran on the ProgramBench benchmark — 200 programs ranging from utilities (jq, ripgrep) to complex systems (SQLite, FFmpeg, a PHP interpreter). The agent sees only the working binary and documentation for the original program, and must reverse-engineer its behavior to write a new implementation. Scoring is the percentage of behavioral tests passed.

Planning pays off at 2x the rate

A full team of Sol agents beat a single agent by 9.7 points (61.8% versus 52.1%), but cost 4 to 7 times more. An asynchronous leader saves time: with a PIV prompt, the team finishes 19.5% faster for the same result.

The core finding: when the leader delegated only planning (Luna agents investigate the program, figure out its behavior, and sketch a plan), it achieved 63.6% accuracy for $249. That's exactly half of the $510 spent by a team delegating all three stages — yet it loses only 0.4 points (63.2% versus 63.6%). Implementation and verification delivered noticeably less — 58–71% with the same 16 agents.

The reason lies in ProgramBench's design: the target program is a black box, and its behavior has to be uncovered through testing. Worker-planners probe different parts of the interface in parallel, and the leader collects their reports and writes the code itself. That's the parallelism that pays off the most.

In the dsq utility case: a single agent with a PIV prompt scored 60%, a team delegating only planning scored 76–79%, and every one of its six runs beat every solo run. Delegating implementation or verification under the same conditions yielded 58–71%.

A secondary benchmark, Commit0-Lite (16 Python libraries with their implementation stripped out but full documentation and tests retained), confirmed the pattern: when the spec is given explicitly, the planning stage remains critical.