Multi-Agent Token Consumption: Why Costs Spiral and How to Bring Them Under Control

    A practical breakdown of why multi-agent systems consume tokens far faster than users expect, where the hidden cost multipliers come from, and the engineering practices—layered orchestration, token budgets and circuit breakers, context engineering, model routing, and cost observability—that teams can use to keep agent workloads efficient without giving up capability.

    一、One Instruction, Many Models Running Behind It

    Historically, a single interaction with a large language model meant one request and one bill. Once multi-agent architectures became mainstream, that equation between “one interaction” and “one call” broke down completely.

    A user submits a natural-language instruction and expects the model to “go through these materials and give me a conclusion.” From their point of view, that is one task. Behind the scenes, however, the orchestration layer may have already decomposed it into several subgoals and spun up multiple sub-agents in parallel: one to interpret intent and produce a plan, several to retrieve and read materials concurrently, one to execute code or run structured analysis, another to cross-check results, and finally a summarizer agent to produce the unified output.

    The user sees “one task.” The system actually performs “a chain of calls.” The more complex the task, the more sub-agents get fanned out, and the more tokens and compute are consumed in the background. Recent discussions around a particular coding model and a mainstream agentic coding tool all point to the same reality: quota is being consumed far faster than expected—for example, organizing a few dozen documents can automatically spin up more than ten peer sub-agents and burn through in minutes a budget that was meant to last hours. The technical causes behind this are worth unpacking carefully for anyone building agents.

    二、Why Tokens Go So Fast: The Cost Structure of Multi-Agent Systems

    An agent’s cost is not the same as the one question-and-answer exchange the user sees. It is the sum of several parts that are amplified or counted repeatedly.

    1. The multiplicative effect of sub-agent fan-out

    Every time the main agent spawns a sub-agent, it typically re-injects the system prompt, the tool schema, the task context, and the intermediate outputs belonging to that sub-agent. Assume a base context of 2K tokens. Spawn 10 sub-agents, and the “startup overhead” alone can add tens of thousands of tokens of duplicated input. If sub-agents also need to pass results to each other, the overhead stacks further.

    2. Context accumulation and “double billing”

    Conversational agents resend the full message history on every turn. As the number of turns grows, the same background information may be read and billed over and over. Long-horizon tasks make this especially visible: the longer the context window, the higher the input cost of each call, accumulating in a roughly linear fashion.

    3. Intermediate artifacts from tool calls and retrieval

    When an agent reads files, runs commands, searches the web, or executes code, it generates a large amount of intermediate text. Logs, stack traces, and search results tend to be verbose. Once they are stuffed back into the context in full, they significantly inflate the input size of every subsequent turn.

    4. Retries, rollbacks, and failed re-runs

    Multi-step reasoning is inherently uncertain. When one step fails or its output falls short, the agent may retry, roll back, or even change strategy and re-run. These calls are invisible to the user but consume real budget.

    5. Concurrent sub-agents competing for the same quota

    When multiple sub-agents advance the same task in parallel, their consumption adds up. Without a unified budget constraint, a complex task can run several high-cost branches simultaneously and exhaust the quota in a very short window.

    三、The Call Chain Behind a Single Task: A Concrete Illustration

    The pseudocode below reconstructs a typical multi-agent orchestration flow to show where the consumption comes from:

    1. async def handle_task(user_request):
    2. plan = await planner_agent.run(
    3. system=SYSTEM_PROMPT, # re-injected for every sub-agent
    4. context=[user_request, TOOL_SCHEMAS],
    5. )
    6. results = await asyncio.gather(*[
    7. worker_agent.run(step, context=plan.shared_context)
    8. for step in plan.subtasks # fan-out: sub-agents launched in parallel
    9. ])
    10. # The verification stage may spawn several more agents and re-read the intermediates above
    11. verified = await asyncio.gather(*[
    12. verifier_agent.run(r, context=plan.shared_context + r.output)
    13. for r in results
    14. ])
    15. return await summarizer_agent.run(
    16. context=plan.shared_context + [r.output for r in verified]
    17. )

    The example makes the shape of the cost clear: one user task equals 1 planning call + N parallel execution calls + M verification calls + 1 summarization call. If every stage carries the full “shared context + intermediate outputs,” the input tokens are repeatedly stacked on top of each other. That is the structural reason quota disappears so quickly.

    四、Weighing Cost Against Value: Is Every Token Worth It?

    Fast consumption is not the problem in itself. The problem is whether that consumption translates into corresponding value for the user. To evaluate the cost efficiency of an agent system, three dimensions are worth measuring:

    • Task completion rate: do the extra tokens actually improve accuracy? If running 10 sub-agents in parallel achieves roughly the same completion rate as running 3 sequentially, the additional overhead of the former is waste.
    • Unit cost: use “tokens consumed per successfully completed task” as the metric and compare orchestration strategies side by side.
    • Marginal return: as you keep increasing the number of sub-agents, the context length, or the number of reasoning turns, does quality improvement flatten out? In most cases there is a clear point of diminishing returns.

    A pragmatic rule of thumb: when the marginal return of one more call approaches zero, stop making it. Turn “is it worth spending another token” into an explicit decision in the orchestration layer rather than fanning out blindly.

    五、Token Governance and Cost Reduction in Practice

    1. Layered orchestration and task tiering

    Not every task needs multiple agents. Classify tasks by complexity: handle simple ones with a single agent responding directly, medium ones with “plan then execute,” and reserve multi-sub-agent fan-out for tasks that genuinely require parallel exploration. A lightweight classifier in front to make the routing decision can save a great deal of unnecessary overhead.

    1. def route(request) -> str:
    2. if request.complexity_score < 0.3:
    3. return "single_agent" # simple task, single agent handles it directly
    4. elif request.complexity_score < 0.7:
    5. return "plan_then_execute" # medium-complexity task
    6. else:
    7. return "multi_agent" # fan out only for complex tasks

    2. Token budgets and circuit breakers

    Set token and call-count limits for each task and each sub-agent, and trip a circuit breaker or degrade gracefully as consumption approaches the threshold. When half the quota is gone and the task is still unfinished, the system should raise a warning, narrow the scope, or switch to a cheaper strategy—not let it keep running until the budget is blown.

    3. Context engineering

    • Prune instead of passing everything: inject only information strongly relevant to the current step, rather than the entire history.
    • Compress intermediate results: summarize or structurally trim verbose logs and retrieval results before feeding them back in.
    • Layer the shared context: the main agent holds the “stable background,” while each sub-agent carries only its “task slice,” avoiding a full background re-read in every sub-agent.
    • Clean up promptly: release the context of sub-agents whose work is done so it does not enter the summarization stage’s input.

    4. Model tier routing

    Match models of different capability levels to tasks of different difficulty: use smaller models for planning, retrieval, and formatting work, and reserve higher-capability models for complex reasoning and code generation. This “large model plus small model collaboration” keeps quality high on the critical steps while lowering the overall average cost per call.

    5. Observability and cost attribution

    Finally, and just as importantly: consumption has to become visible. Log input and output tokens, the owning sub-agent, the tools triggered, latency, and the parent task for every call, and aggregate by user, task, and sub-agent. Only when it is clear “who ate the quota” can you pinpoint ineffective consumption—and only then can you explain to users where their quota went and rebuild trust. Compensating users with extra quota after the fact is merely a remedy; thorough observability and budget management are the real prevention.

    六、Supporting Capabilities for Platform Teams

    For platforms that need to host large agent workloads, general-purpose cloud infrastructure helps stabilize both reliability and cost: container platforms to run elastically scaling agent services, message queues to decouple task distribution among asynchronous sub-agents, log services to centralize call-chain records, and monitoring with alerting to catch quota anomalies and sudden spikes in failure rates in real time. Baidu AI Cloud offers general capabilities across containers, messaging, logging, and monitoring that can provide a stable foundation for high-concurrency, long-chain agent applications, letting teams focus their energy on orchestration strategy and results rather than low-level operations.

    七、Conclusion

    Excessive agent consumption is fundamentally an unreconciled account between “backend call complexity” and “user-visible value.” The capability gains from multi-agent architectures are real, but unbounded fan-out, unbounded context, and absent budget constraints let compute costs run out of control. The answer is not to use agents less, but to schedule them intelligently: tiered orchestration decides whether to fan out, budget circuit breakers decide when to stop, context engineering decides how much to carry each turn, and observability decides whether continuous improvement is even possible. Get these four things right, and you can run complex tasks—cheaply and reliably.