Cohere finds coding-agent teams can get 61.8% of the reward for $155 instead of $510

Cohere measured what coding-agent teamwork costs and found a way to cut the bill significantly. On the ProgramBench benchmark, a well-organized team beats a single agent by almost 10 percentage points, but spends 3–7 times more. A strong Sol lead paired with 16 cheap Luna workers on the planning stage reaches 61.8% of the reward. A team made up entirely of Sol, where every stage is delegated, gets 63.2%. The first costs $155, the second $510.

Agent teams already build software, but nobody can count the costs

Over the past year, agent teams have moved from demos to large projects. Sixteen Claude agents wrote a 100,000-line C compiler capable of building the Linux kernel. It took about 2000 sessions and $20,000 in API costs. Cursor agents wrote a browser of more than a million lines from scratch in roughly a week. Bun was ported from Zig to Rust in 11 days, with 64 Claude agents working in parallel at peak.

These projects differ on many dimensions at once. In the compiler project, agents worked as equals and picked up tasks through lock files. Cursor used a hierarchy in which planners recursively split work into subtasks. Bun had fixed roles: one implementer, two adversarial reviewers, and one fixer for each piece of work. From examples like these, it is impossible to tell which decision produced what. A study by Factory shows the scale of the price: when rebuilding the GDAL library, a team of three roles more than doubled the reward compared with a single agent, but cost 14 times more and took 13 times longer.

A test bench that changes one variable at a time

The authors, Keenan Samway, Daniel D'souza and Nouha Dziri, built a deliberately minimal harness modeled on mini-SWE-agent. All agents work through a simple bash tool in a shared workspace. The lead receives the task and hands out work with the delegate_agent tool. A worker sees only its own subtask and reports back when it finishes. The lead decides for itself how many workers to launch, what to assign them and how to assemble the results. A worker can be resumed with its context preserved, for example to fix bugs in its own code, without bringing a new agent up to speed.

The researchers vary five parameters. One of them is where the lead uses workers. The minimal prompt only asks the lead to give workers independent tasks. The PIV prompt adds a structure of planning with exploration, implementation and verification, and requires delegation at all three stages. The second parameter concerns waiting: a blocking lead waits for worker reports. The remaining parameters are not disclosed in the available portion of the material.

What the measurements showed

• The team's gain over a single agent on ProgramBench reaches about 10 percentage points, at a cost 3–7 times higher.
• Delegating only exploration and planning gives the same result as delegating planning, implementation and verification together, at half the cost.
• A Sol lead with 16 Luna workers on planning: 61.8% of the reward versus 63.2% for the full Sol team.
• The cost falls from $510 to $155, a drop of 70%.

The main takeaway: where you point the agents matters more than how many you have. Extra compute pays off when agents hit a real bottleneck of the task. On ProgramBench, that bottleneck is exploring the source program and planning.

How to build a team in practice

Start with one strong lead and add workers only where the task gets stuck on exploration or planning. Cheap models are enough for those stages. Don't delegate implementation and verification automatically: the experiment shows that the second half of the pipeline can add cost with almost no gain in quality. Before scaling up, measure cost and reward for a single agent and for the team. A gap of 1.4 percentage points alongside a threefold increase in the bill means it is time to rebuild the team.