Day 26 — The Bill Between Agents
Day 25 opened the interface arc with a single frame: the interface between a user and a model decides how much inference gets called, at what tier, at what size. Today’s issue closes the arc by turning to the newest interface in the AI stack. The one between agents.
As agentic systems become multi-agent systems, they introduce boundaries where one agent invokes another. An orchestrator decomposes a task and calls specialists. A specialist calls back to a peer for verification. A workflow graph hands the output of one agent as the input to the next. A tool call may cross an MCP boundary. A delegated task may cross an A2A boundary to another agent. Each of these is an interface, and each of these interfaces carries the same three levers Day 25 named: how often the call fires, which model tier serves it, and how much context travels across the boundary.
The distinctive thing about the agent-to-agent boundary is that these amplifications compound. Fan-out increases calls. Escalation increases tier. Accumulated state increases payload. Loose contracts create retries. A five-agent workflow with modest inefficiency at each boundary can produce substantially more inference demand than a simpler architecture delivering the same required outcome. The interface between agents is where amplification compounds, and the bill accumulates along a path that usually no single team owns end to end.
The Spark
Consider a customer support platform that runs on an agentic AI stack. A single user question enters at the top. A supervisor agent decomposes the request, routes to a triage agent, which routes to a category-specific specialist, which consults a knowledge agent for retrieval, then a policy agent for compliance verification, then hands back to a drafting agent that composes the final response. The architecture diagram is clean. The user-facing latency is acceptable. Adoption is growing.
Six months in, the platform team pulls a per-request inference count. A typical customer question, at the top of the stack, is producing more inference calls than anyone had modeled. The audit surfaces the interfaces between agents, not the agents themselves. Four patterns are amplifying demand at every boundary the request crosses.
The chatty orchestrator. The supervisor decomposes every incoming request into six or seven sub-tasks by default, some of which the request does not actually require. The decomposition prompt was written early, when the team wanted the supervisor to be thorough, and has never been tightened. Simple questions get decomposed into the same fan-out as complex ones. Every sub-task is a specialist invocation. Every specialist invocation is an inference call. The supervisor is calling agents the request never needed.
The specialist that escalates. The category specialists are mid-tier models by design. When the system’s uncertainty or escalation heuristic crosses a threshold, the specialist escalates to a frontier-tier model to double-check. The threshold was set conservatively at launch, and later model improvements have made the mid-tier specialists more capable, but the escalation rate has not been re-tuned. A meaningful fraction of requests now escalate to the frontier tier for verification the specialist would have gotten right on its own.
The state that travels. The shared state object accumulates across the workflow. Each agent receives everything the previous agents produced, plus the original user context, plus every retrieval result, plus every tool response. By the time the drafting agent runs, its input contains accumulated upstream messages, intermediate outputs, retrieval results, and tool responses. A request that entered with a small prompt can arrive at the drafting agent with a payload many times larger. The drafting agent uses only a small fraction of what it receives. It pays inference on all of it.
The clarification loop. The interface between two specialists is a loosely-defined message contract. When one specialist returns a response in a shape another specialist cannot immediately parse, the receiving agent calls back to ask for clarification. Sometimes the round-trip resolves in one call. Sometimes it takes three. The contract between agents was designed for flexibility, and flexibility has become a source of avoidable inference every time two agents fail to speak the same shape.
The user asked one question. The interface between agents asked all the rest.
The obvious objection is that agent decomposition, specialist escalation, shared state, and flexible contracts are all architectural strengths of modern agentic systems. That is true. The argument is not that agents should not talk to each other. The argument is that every handoff between agents is an interface, and every interface has an amplification profile. In an agentic system, those profiles compound. A five-agent workflow with modest amplification at each boundary produces a total demand that grows sharply with graph depth and fan-out. The compounding is invisible unless the interfaces themselves are measured.
When Amplification Compounds
Day 25 introduced three dimensions of interface amplification: how often the model is called, which tier is called, and how much is sent per call. At the user-to-model boundary, those three dimensions live at one interface. At the agent-to-agent boundary, they live at every interface the request crosses, and they compound through the graph.
In agentic systems, amplification compounds across the graph in four distinct ways.
Fan-out increases calls. If the supervisor decomposes into five agents on average, and some of those agents call downstream tools or peers, one user request produces a growing number of agent invocations before the final agent runs. Fan-out at each layer composes with fan-out at every layer above it, and the total call count grows with graph depth.
Escalation changes tier. When layers of the stack route a meaningful share of work to progressively higher tiers, whether by default or through conservative escalation, inference cost can rise as work moves deeper into the graph. A supervisor on a fast model, calling specialists on a mid-tier model, that escalate to a frontier model on uncertainty, produces a stack whose bottom layer is drawing frontier-tier inference for tasks the top layer thought were routine.
Accumulated state increases payload. If every downstream agent inherits the full state of every upstream agent, the payload each agent ships grows as the request descends the graph. A request that entered at the top with a small prompt can arrive at the drafting agent with a payload many times larger, accumulated from every upstream message, intermediate output, retrieval result, and tool response. The bill grows with depth.
Loose contracts create retries. When two agents fail to agree on message shape, the interface between them fires additional calls to reconcile. Each clarification round-trip is inference that would not have been required if the contract had been tight.
The compounding is not a bug in agentic architecture. It is a natural consequence of composing interfaces without measuring what each interface is doing. Small inefficiencies at individual boundaries become large system-level bills. Making the compounding visible is the precondition for controlling it.
The Ladder
Four rungs move the agent-to-agent boundary from an unmeasured cost center into a governed one.
Trace. Interface teams saw per-surface amplification in Day 25. Agent teams need per-boundary tracing across the whole graph. Instrument every agent handoff with the request identifier, the calling agent, the called agent, the model tier, the input size, and the output size. Aggregate by request path. The core measures are total calls, model-tier mix, and input/output volume per user request, attributed to the handoffs that produced them. That triple lines up with Day 25’s three dimensions, and it prevents the trap of optimizing call count alone: one very large frontier-model call can matter more than several tiny fast-model calls. Without a trace that captures all three, the compounding stays invisible.
Contract. The interface between two agents is a contract. Loose contracts produce clarification calls, oversized payloads, and re-runs when the receiving agent cannot parse what the sending agent produced. Tight contracts specify what each agent expects to receive, in what shape, at what size, and what each agent commits to return, in what shape, at what size. Message schemas, response shapes, size caps, and required fields are the tools. The contract does not restrict what the agents can do; it restricts what they have to negotiate at runtime. Every negotiation avoided is an inference call not made.
Compact. Not every downstream agent needs the full upstream state. A drafting agent that uses only a small fraction of what it receives is paying inference on the rest, and the rest carries no useful signal. Compaction at the boundary means each handoff ships only what the receiving agent actually needs. Summarization of upstream outputs and state, filtered retrieval results, and scoped tool responses replace the pattern of shipping the accumulated state of the entire graph. Compaction is the agent-boundary equivalent of the payload deferral principle from Day 25: send only what is needed.
Consolidate. Agent graphs accumulate. Specialists get added when new categories emerge and rarely removed when categories consolidate. Escalation paths get added conservatively at launch and rarely re-tuned. Workflow graphs branch and multiply. Consolidation asks, for every agent in the graph, whether the agent still earns its place. Low utilization alone is not a reason to remove an agent. A specialist serving a small fraction of requests may exist for exactly the compliance, safety, or rare-category workflow that justifies it. But an agent that rarely fires, adds little measurable capability, or routinely produces output the next stage discards deserves review. Consolidation is not about removing agents for the sake of removing them. It is about right-sizing the graph to the workload it actually serves.
The Lens
The agent-to-agent boundary crosses every seat at the table, and it usually has no single owner because the graph itself spans multiple teams and services.
Engineering. Every agent an engineering team ships is a component in a larger graph the team does not own end to end. Instrumentation at each boundary is the engineering seat’s contribution to making the whole graph measurable. Contract discipline at each interface is the engineering seat’s contribution to making the graph efficient.
Architecture and CTO. The agent graph becomes an architectural artifact in its own right, with a documented topology, a per-boundary cost model, and a per-boundary contract. The graph diagram gains an amplification annotation on every edge. Decisions about decomposition, escalation, and consolidation happen at the architectural level, not at each agent’s own design review.
Platform and Infrastructure. Per-boundary metering joins per-agent metering on the observability plane. Cross-agent tracing infrastructure is a first-class capability, not a nice-to-have. Capacity planning includes the compounded amplification of the graph, not only the throughput of any individual agent.
Sustainability and ESG. Emissions accounting for agentic systems now includes per-request amplification profiles alongside per-agent inference numbers. Reporting distinguishes the user-level workload from the additional inference introduced by orchestration, fan-out, retries, escalation, and accumulated state.
Business and Product. Product decisions about agent capability are now decisions about graph amplification. Adding an agent to the workflow adds a handoff to the bill. Removing an agent reduces one. The roadmap conversation about what agents to add gains a companion conversation about the amplification each addition carries.
Five seats, one graph.
The Move
The work begins with a request trace and ends with a graph budget.
Pick one representative user request. Trace it end to end through the agent graph. For that single request, record a small profile: total calls, input tokens, output tokens, model-tier mix, retry and clarification rate, and cost where available. Attribute each number to the handoffs that produced it. Compare the traced graph against the simplest architecture that could deliver the same required outcome and quality level. The comparison gives you an amplification profile for that request class, without implying the simplest architecture is the right answer.
Repeat for two more request classes: the simplest and the most complex the graph handles. The three profiles together characterize the graph’s amplification behavior across the workload.
Pick the highest-amplification request class and ask four questions. Is the fan-out at the supervisor level a chosen design or an inherited default? Is the escalation to higher tiers still calibrated to current mid-tier capability? Is the payload each downstream agent receives compacted to what it actually needs? And is every agent in the path earning its place, or is the graph over-decomposed for this request class?
Publish the graph amplification profiles, the per-boundary contracts, and the consolidation decisions in the agent architecture guidelines. Establish a quarterly re-trace of the three representative request classes against current numbers.
One trace, one profile, one review cadence. That is the work.
The Receipt
If you remember one line from today:
Every handoff is an interface. Every interface has a bill. Across an agent graph, those bills compound.
Day 27 opens the final arc of the series. Governance. Ownership of the ledger, the numbers, and the discipline that keeps AI systems intelligent in what they produce and efficient in how they run.