Multi-agent handoff cost: what a 3-agent chain uses in tokens

Your three agents finished the job, and the bill is bigger than the job looks. The reason is simple: with text handoffs, every agent pays to read everything the agents before it wrote. A 1,500-token plan is paid for once when the planner writes it, then again by the coder, then again by the reviewer. Trim the handoff, hand each agent only what it needs, and the input of every later agent gets smaller.

Below: a worked 3-agent example with its token math, a cost estimate for 100 tasks a day on live prices, and three changes you can make today. Chat-completions APIs are stateless, so every request carries its full context again (why a long chat costs more and how the messages array works cover the basics).

Where the tokens pile up#

Say you run a planner, a coder and a reviewer. The task plus instructions is 1,000 tokens. The planner writes a 1,500-token plan, the coder writes 3,000 tokens of code and notes, the reviewer writes an 800-token verdict. These are round numbers for the example, not a measurement; swap in your own from the usage field (how to read it).

Each agent's input is the task plus every handoff it receives:

The chain reads 9,000 tokens to produce 5,300. Add a fourth agent and it would read the task plus all three handoffs, so input grows with every hop, not just by one handoff.

What 100 tasks a day cost#

A handoff token is billed once as output, when the agent writes it, and then as input for each later agent that reads it. Output tokens are priced higher than input tokens, so in this example the answers are the larger share of the bill even though the chain reads more than it writes (input vs output tokens).

One task is 9,000 tokens in and 5,300 out. On MiniMax-M2.7 that is $0.0012 per task. For 100 tasks a day, these are the live prices across our models, next to OpenRouter:

In total, with input and output counted together, the CheapTokens models above come out cheaper than OpenRouter for this chain.

Want the calculation for your own chain? Put the average request of one agent into the calculator: about 3,000 tokens in and 1,800 out, repeated 300 times, is 100 tasks of three agents.

Three ways to shrink the bill#

1. Make the handoff a short structured note#

The planner does not need to write an essay for the coder. Ask for fields: goal, files, steps, constraints. Say a short note of eight one-line steps takes about 400 tokens instead of 1,500 (an assumption: put your own number from usage), and every later agent reads that smaller note. Cap the answer with max_tokens, set a bit above the expected note, so a chatty model cannot sneak the essay back in.

import os
from openai import OpenAI

client = OpenAI(
    base_url='https://api.cheaptokens.dev/v1',
    api_key=os.environ['CHEAPTOKENS_API_KEY'],
)
task = 'Add a --dry-run flag to the export command'

plan = client.chat.completions.create(
    model='deepseek-ai/DeepSeek-V4-Flash-0731',
    max_tokens=500,
    messages=[
        {'role': 'system', 'content': 'Reply with JSON only: {goal, files, steps, constraints}. At most 8 steps, one line each.'},
        {'role': 'user', 'content': task},
    ],
)
note = plan.choices[0].message.content
print(plan.choices[0].finish_reason, plan.usage.completion_tokens)

If finish_reason is length, the note was cut off by the cap: raise max_tokens a little or shorten the schema (what that error looks like). Model id and base URL are in the CheapTokens docs.

2. Pass each agent only what it needs#

If the reviewer checks the code against the task, it does not need the plan: the task and the code are enough. If it also checks the code against the plan, keep the plan. Cutting the plan out of its context is a one-line change in your orchestrator:

With both changes (and the 400-token note, which is our assumption), the example chain becomes planner 1,000 in and 400 out, coder 1,000 + 400 = 1,400 in and 3,000 out, reviewer 1,000 + 3,000 = 4,000 in and 800 out. That is 1,000 + 1,400 + 4,000 = 6,400 tokens in and 400 + 3,000 + 800 = 4,200 out, against 9,000 and 5,300 before. Same 100 tasks a day:

For one task on MiniMax-M2.7 the trimmed chain is $0.00095, down from $0.0012.

3. Give short roles a cheap model#

The planner writes short answers, so start there: try GLM-5.3-Flash (390K context, up to 8,192 output tokens per answer) and compare the result on 10–20 of your own tasks. The coder writes the longest answers: DeepSeek-V4-Flash allows up to 32,768 output tokens per answer. Since every model sits on one balance with one price at any hour, mixing them in one chain needs only a different model string per agent. Current prices for both are in the pricing table and on the DeepSeek page.

Why not just pass the KV cache?#

The paper SwaT (arXiv:2610.15095), submitted on 10 October 2026 by Alabdulkareem, Tenison, Zhang, Zhu, Katz and Gutfreund, proposes exactly that: agents hand each other KV-cache state instead of text, so the receiver skips reading the text again. According to the abstract page (read on 31 October 2026), the authors report 40% higher mean accuracy (with KV-cache compaction) than text-to-text communication and 4x faster mean wall-clock time across 17 benchmarks, 12 LLMs and 6 model families. The 40% is accuracy, not a saving on tokens or price.

A research method like this needs access to the model's internal cache. A chat-completions request takes text in and gives text out, so with an API your lever is the text: the three changes above.

Before you scale to hundreds of runs#

For the bigger picture of agent budgets, see how to estimate the cost of an AI agent and why agents use so many tokens.