The price gap nobody draws on the architecture diagram
Here is the Fable 5.1 price list, the three lines that matter.
| Token type | Price per million |
|---|---|
| Cache reada document the model has already seen | USD 0.25 |
| Fresh inputnew context, for example a sub-agent's brief | USD 10.00 |
| Outputanything a model writes | USD 50.00 |
A swarm diagram shows boxes and arrows. Each arrow is the main agent generating tokens at the output price. There is no shared memory between agents; nothing moves between them for free. The only way to give a sub-agent context is to re-tell it. A sub-agent is a photocopier, and the copies are made at the most expensive rate on the price list.
A small, honest example
- A main agent reads a 10,000-token document.
- It has 3 tasks to do on that document.
- It spins up 3 sub-agents. To brief each one it writes the task plus the relevant context: about 3,000 tokens each.
- Each sub-agent answers in about 300 tokens.
- The main agent reads the 3 answers and writes a 900-token final response.
Here is what the meter records. Costs are per 1,000 runs so the small numbers are visible.
| Step | Tokens | Cost / 1,000 runs |
|---|---|---|
| Main agent reads the documentcache read | 10,000 | USD 2.50 |
| Main agent writes 3 briefsoutput, 3 × 3,000 | 9,000 | USD 450.00 |
| 3 sub-agents read their briefsfresh input, no cache hit | 9,000 | USD 90.00 |
| 3 sub-agents answeroutput, 3 × 300 | 900 | USD 45.00 |
| Main agent reads the 3 answersfresh input | 900 | USD 9.00 |
| Main agent writes the final answeroutput | 900 | USD 45.00 |
| Swarm total | 10,800 output | USD 641.50 |
Look at the second row. The main agent had already read those 9,000 tokens for USD 2.25. It then re-typed them for USD 450.00: two hundred times the price, to tell three helpers what it already knew.
Watch the meter
Press play. Tokens move between the document, the main agent, the sub-agents and you. A price tag pops on whoever pays, and the meter counts. Then the single agent runs the same three tasks, and the two bills sit side by side.
The boring alternative
One agent. Read the document once. Do task 1, then task 2, then task 3, in the same context. Each turn re-reads the document from cache.
| Step | Tokens | Cost / 1,000 runs |
|---|---|---|
| Read the document, 3 turnscache read, 3 × 10,000 | 30,000 | USD 7.50 |
| Answer the 3 tasks one by oneoutput, 3 × 300 | 900 | USD 45.00 |
| Single agent total | 900 output | USD 52.50 |
The bill
| Same 3 tasks | Swarm | Single agent |
|---|---|---|
| Output tokens generated | 10,800 | 900 |
| Output tokens that are the answer | 900 (8%) | 900 (100%) |
| Cost per 1,000 runs | USD 641.50 | USD 52.50 |
Twelve times the output tokens. Twelve times the money. And of the 10,800 output tokens the swarm generated, 900 are the answer. The other 9,900, 92 percent, are coordination: the main agent telling helpers what it knew, then re-telling their answers back to me.
Of every twelve output tokens the swarm paid for, eleven were the agents talking to each other.
It is not only money
- The brief is lossy. Each sub-agent sees 3,000 of 10,000 tokens. The main agent decided what to cut before it knew what the sub-agent would need. That is a game of telephone, and you pay output price to play it.
- Parallel saves time, not money. Three sub-agents finish faster on the clock. The meter does not care. Most swarm demos sell the first and hide the second.
When a swarm is actually worth it
- The material does not fit in one context window.
- The tasks need different tools, permissions or isolation from each other.
- Wall-clock time matters more than cost, and you have checked that it does.
- The sub-agents run a much cheaper model. Even then, remember the briefs are still written by the expensive one.
If none of these apply, you are paying for the diagram.
The rule
Read once. Keep the context. Do the tasks one by one.
Prompt caching made re-reading almost free. Delegation makes re-telling the most expensive thing you can do with a model. It is one of the reasons E1pi does not run agent swarms: a person starts the session, steers it and approves what goes out, and the model does the work in between, in one context.
Prices in this post are the Fable 5.1 list prices on the day of writing: input USD 10.00, output USD 50.00, cache read USD 0.25 per million tokens. The one-time cache write of the document is the same in both cases and is left out. Read more at e1pi.com.