Cohere coding-agent teams — Planning-only delegation — What does it mean?
The news. On October 14, 2026, Cohere reported results from a controlled testbed of lead-worker coding teams on 200 ProgramBench tasks. Teams gained up to about 10 percentage points of reward over a solo agent, at 3–7× the cost, and the gain depended heavily on which stage the lead delegated. Read the post →
Picture an architect who must rebuild a building from nothing, with no blueprints. The only way to learn what is inside is to walk around and measure. Hiring more hands does not help while nobody knows what to build, but hiring surveyors does. That is the shape of Cohere's result. In their harness the lead is the architect, and delegate_agent is how it sends surveyors off in parallel, each probing a different corner of the program's interface.
The testbed is deliberately small: every agent has one bash tool and a shared workspace, and the experiment changes one design choice at a time (where the lead uses workers, whether it waits, which models fill which role, how many workers, and whether workers can message each other). In ProgramBench the target is a black box, so discovering what the program does is the bottleneck, and planning workers attack exactly that bottleneck. Among asynchronous Sol teams, a lead that delegated only exploration and planning reached 63.6% reward against 63.2% for one that delegated all three stages, at $249 against $510 (the post's averages over three runs of 200 tasks). The same logic holds for any a team of agents: extra agents only help when they land on the real constraint, because each one adds coordination cost.
| Team setup (200 tasks) | Reward | Total cost |
|---|---|---|
| Solo Sol agent, PIV prompt | 57.7% | baseline |
| Sol team, delegates all three stages | 63.2% | $510 |
| Sol team, delegates planning only | 63.6% | $249 |
| Sol lead + 16 cheap Luna planners | 61.8% | $155 |
Now the worked example. Hold the benchmark (200 tasks), the lead model (Sol) and the asynchronous lead fixed, and vary only the workers. The all-stage team scores 63.2% for $510. Delegating planning only scores 63.6% for $249, so it gains 0.4 points while saving $261. Swapping the planners for 16 cheap Luna workers scores 61.8% for $155, which is $355 less than the all-stage team for 1.4 points less reward. That is 30% of the cost ($155 / $510) for about 98% of the reward (61.8 / 63.2). The planners can be cheap because they mostly gather information for the lead rather than make the hard decisions.
Three limits keep this from becoming a rule. First, the lead still has to be strong: with Luna workers fixed, upgrading the lead from Luna to Terra to Sol raised reward from 42.5% to 51.6% to 60.5%, and a Terra lead with Luna workers (51.6%) still fell short of a solo Sol agent (57.7%). Second, the winning stage depends on the task. On Commit0-Lite, where the repository already spells out what to build, delegating implementation was the most effective stage in eight of ten team setups. Cohere treats that as suggestive only, because the benchmark has 16 tasks and a capable solo agent already passes every test on 12 of them. Third, waiting matters: with the PIV prompt the asynchronous team finished 19.5% faster than the blocking one at about the same reward, but with the minimal prompt its lead delegated less (4.4 times per task against 6.1) and gained far less.
The practical reading is a cost profile question before it is an architecture question: find the stage where your task is stuck, put cheap parallel workers there, and keep one strong decision-maker. The pattern is a variant of orchestrator-workers, with the cost placement made explicit. These numbers come from one lab's benchmark with GPT-5.6 models, so treat the ratios as indicative rather than universal.
Goes deeper in: Agent Engineering → Agent Teams → When Teams Beat a Single Agent
Related explainers
- Explorer-subagent context offloading — another case of cheap read-only helpers doing the searching so the main agent does not.