---
title: "Study 7: 1 to 16 AI coding agents, 24% fewer tokens at one, 47% at sixteen · Cork"
description: "One to sixteen Claude Code agents at once on one repo, five rounds each with Cork and without: 24% fewer tokens at one agent, 47% at sixteen. The rise at eight and sixteen agents is landing, which removes the push-rejected, rebase, retest loops that take 43% of the agents' tokens without it. Leave landing out and the rest saves 2–8% at four agents and more."
canonical: "https://corkcli.com/benchmarks/study-7-scaling-to-sixteen-agents"
last_updated: "2026-11-14"
---

# Does Cork save more as you add agents? About a quarter up to four, then 47% at sixteen

We ran 1, 2, 4, 8, 16 Claude Code agents at once on one repository, five rounds at each size with Cork and five without: same tasks, same prompts, same model. The saving holds at about a quarter from one agent to four, then rises: a third at eight, nearly half at sixteen. That rise comes from one feature, landing. Without it, agents fight over the push, and that fight grows faster than the team. The rest of Cork saves much less at scale, and this page says why.

47%
:   fewer tokens at 16 agents (± 3)

24%
:   fewer at 1 agent (± 15)

43%
:   of tokens spent re-pushing at 16 agents without Cork

151/155
:   tasks correct, vs 151/155 without

## The curve

Tokens saved with Cork at each size, the mean of five rounds with one standard deviation either side. The dashed line is the saving with the control agents' push-retry loops taken out: what the rest of Cork saves.

tokens savedwith push-retry loops left out

## The numbers

Mean ± standard deviation per run over five rounds. Tokens are input, cache writes, cache reads and output, as the provider reported them for each agent. Correct means the task's hidden acceptance tests pass on the final shared origin. Where a cell holds two numbers, the first is with Cork.

| Agents | With tokens | Without tokens | Saved | Correct | Rejected pushes | Merge conflicts |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | 0.43M ± 0.06M | 0.57M ± 0.06M | 24 ± 15% | 5/5 vs 5/5 | 0 vs 0 | 0 vs 0 |
| 2 | 0.96M ± 0.21M | 1.31M ± 0.12M | 26 ± 18% | 10/10 vs 10/10 | 0 vs 1 | 0 vs 0 |
| 4 | 2.82M ± 0.32M | 3.73M ± 0.40M | 24 ± 4% | 19/20 vs 19/20 | 0 vs 3.4 | 0 vs 0 |
| 8 | 4.92M ± 0.48M | 7.40M ± 0.66M | 33 ± 7% | 38/40 vs 39/40 | 0 vs 9.2 | 0 vs 2.4 |
| 16 | 9.38M ± 1.26M | 17.66M ± 2.54M | 47 ± 3% | 79/80 vs 78/80 | 0 vs 40.6 | 0.4 vs 7.6 |

With and without, per agent: 0.43M vs 0.57M at one agent, 0.59M vs 1.10M at sixteen. Without Cork each agent costs more as the team grows; with it the cost per agent stays nearly flat. At sixteen agents, runs with Cork also finished 26% sooner (167s vs 226s) and cost $3.83 vs $6.25. Per-round savings are in [the data](https://corkcli.com/benchmarks/study-7-scaling-to-sixteen-agents/data.json).

## Where the saving comes from

When several agents push to one origin, all but the first are rejected. Each then pulls, rebases, retests and tries again, and is often rejected again. The number of these collisions grows roughly with the square of the team. Cork's landing rebases, retests and pushes in one step: the agents with Cork had no rejected pushes at any size.

| Agents | Push-retry loops, without | Share of its tokens | Saved with those left out |
| --- | --- | --- | --- |
| 1 | 0 | 0% | 25% |
| 2 | 0.23M | 17% | 12% |
| 4 | 0.85M | 23% | 2% |
| 8 | 2.07M | 28% | 8% |
| 16 | 7.57M | 43% | 7% |

A push-retry loop is every model call between a rejected push and the next push that succeeds. Cork's own savings ledger agrees: at sixteen agents it credits landing with 1.70M per run, change notices with 0.85M, map answers with 0.53M and briefings with 0.43M. Merge conflicts at sixteen agents fell from 7.6 to 0.4 per run.

## The caveat: the rest of Cork barely helps at scale, yet

Take landing out and Cork's other features save 25% at one agent but only 2–8% at four agents and more. The briefings and the map still save tokens. What cancels them is how agents react to Cork's notices.

The notices themselves are cheap to carry, about 4% of an agent's tokens at every size. What costs is what they make an agent do: a “your copy is behind, pull” nudge makes it pull and re-read; a block on a shared test file makes it wait and poll; a “tell the others” prompt makes it load a tool. Per run, with Cork:

| Agents | Notices carried | Reactions to notices | Waiting at the gate | Cork tool calls |
| --- | --- | --- | --- | --- |
| 1 | 18K | 0 | 0 | 0 |
| 2 | 42K | 78K | 0 | 68K |
| 4 | 112K | 278K | 149K | 260K |
| 8 | 192K | 662K | 182K | 283K |
| 16 | 386K | 1,257K | 802K | 526K |

A reaction is the next one or two model calls after a notice when they pull, inspect git, re-read the file the notice names or call a Cork tool. Waiting is every call from a gate block on a file until the next write to it. A call can count in both columns, so they overlap and do not add up exactly.

## What it led to

Five fixes, ranked by the tokens the study says each would save per run. They are being built; a follow-up study will measure them, and this page will not be rewritten when it does.

1. 1.Let additive writes to a shared test file through, with a one-line notice instead of a block. about 160K at 8 agents, 600K at 16
2. 2.Stop telling agents to pull mid-task when landing is on; landing rebases anyway. about 250K at 8 agents, 470K at 16
3. 3.Send each change notice once, and only to agents whose next write touches it. about 150K at 8 agents, 300K at 16
4. 4.Never tell an agent to pull a change that is not on origin yet. about 100K at 8 agents, 200K at 16
5. 5.Fewer Cork tool calls: a one-line cork message instead of an MCP schema load. about 150K at 8 agents, 250K at 16

Together, about 0.80M at eight agents and 1.80M at sixteen. If the estimates hold, sixteen agents would go from 47% toward 57% saved, and the features other than landing would save more as the team grows, not less. Those are estimates, not measurements.

## How it was run

- **The work.** Study 3's hardest tier, twelve vague tickets in a 654-file Python repository with decoys, plus four new tasks that pile onto the same functions and files. The sets are nested: one agent gets one task, two get that task and one more, and so on up to sixteen. Every agent shares the test folder. Each agent had its own clone and pushed to one shared origin.
- **With Cork.** Set up the way a person sets it up: the MCP setup returned one install line, which installed hooks v74 for the machine. Prompts were matched to code by meaning, as in production. Every run got a fresh account, a fresh paid workspace and a fresh repo.
- **Without.** The same agents, prompts and flags with no Cork.
- **Both.** Claude Sonnet 5, every agent launched at once, at most 80 turns each. Any agent whose work had not reached the origin got one identical wake-up message. The two arms alternated which went first in each round.
- **Isolation.** Midway through, we found that the agents could message other Claude Code sessions on the machine, which also let control agents coordinate without Cork. Every affected run was discarded. Cross-session messaging was then switched off for both arms, and each run records whether it was used: all 50 runs here show none. Runs from two sweeps that overlapped by mistake, and runs that reused a repo from an earlier run, were discarded too.
- **Cost.** $94 of model usage for the 50 runs kept.

## What this study does not show

- One person's machine per run, and every agent started at the same moment rather than over a working day.
- At one and two agents the spread is wide (± 15 and ± 18 points): single rounds there ranged from 8.6% to 40.1%.
- Both arms failed the same few tasks. Most failures were one task whose ticket can be read two ways, in both arms.
- With messaging switched off, Cork's push of messages into a running session was not exercised.
- In dollars the gap is smaller than in tokens, because much of each session is billed at the cache-read rate.

## The data

Every number on this page is in [data.json](https://corkcli.com/benchmarks/study-7-scaling-to-sixteen-agents/data.json), generated from the runs' recorded sessions. The harness that ran them is not public yet.

[All studies](https://corkcli.com/benchmarks)[Install Cork](https://corkcli.com/install)

This page in HTML: https://corkcli.com/benchmarks/study-7-scaling-to-sixteen-agents