What does prompt chaining between two LLM agents cost in tokens and fidelity?

## What prompt chaining is Prompt chaining is the most basic way two LLM agents talk: agent A runs, produces output text, and that text is inserted into agent B's prompt — usually as a block like *"Here is the analysis from the previous step: …"*. No protocol, no schema, no transport beyond a string concatenation in your own code. It is how almost every multi-agent system starts, and for short pipelines it is often the correct answer. It is worth naming what chaining actually transfers: **text, and nothing else**. The receiving agent does not get A's tool results, A's confidence, A's retries, or A's reasoning state. It gets the words A happened to emit, in a prompt slot that carries no more authority than any other sentence in the context. ## The token cost A language model is charged on input tokens for the whole context on **every** call. If agent A emits a 6,000-token report and you paste it into agent B, that 6,000 tokens is billed on B's first model call — and again on B's second call, and its third, because B's own transcript (its tool calls and results) is appended to a context that still contains the pasted block. An agent that takes ten turns to finish has paid for that block ten times. Chains compound this. In A → B → C, if each step forwards what it received plus what it produced, context grows super-linearly and the last agent in the chain is the most expensive one to run. This is a large part of why orchestrated multi-agent systems burn far more tokens than a single-agent chat for the same task — reported multiples of an order of magnitude are common for research-style pipelines. ## The fidelity cost The fidelity problem is the one candidates usually miss. - **Provenance is erased.** A's grounded citation and A's guess arrive in B's prompt as the same kind of text. B has no signal for which is which, so B will treat a fabricated supplier price with the same seriousness as a retrieved one. Errors do not get filtered by the hop; they get laundered by it. - **Attention is diluted.** Model quality degrades as the window fills — the common name for this is *context rot*. A large pasted block competes with B's own system prompt and task instructions, and the longer the block, the more likely B drifts from what it was actually asked to do. - **Ambiguity survives.** A's hedged sentence ("the lead time is probably around two weeks") becomes B's input. B must either re-derive the uncertainty or, more often, flatten it into a confident downstream claim. - **Format drift.** Because the channel is free text, A can change its output shape between runs — a heading disappears, a list becomes prose — and B's parsing or reasoning silently changes with it. There is no failing test at the boundary; there is only a worse answer. ## Narrowing the seam The standard remedy is to make the handoff *smaller and more structured*, not to abolish it: 1. **Have A emit a condensed result, not its transcript.** In production orchestrator/subagent designs, a subagent that did a great deal of work returns on the order of one to two thousand tokens of findings. The exploration stays in A's own context and dies with it. 2. **Give the payload named fields.** `supplier`, `unit_price`, `currency`, `lead_days` is both cheaper and checkable; the receiver can validate it before spending a model call on it. 3. **Pass references, not contents.** Hand over an identifier or a path to an artifact and let B fetch only what it needs. 4. **Mark provenance.** If a field came from a tool result rather than from the model's own inference, say so in the payload, so B can weight it. ## When plain chaining is right Do not over-engineer. If the pipeline is two steps, the intermediate output is a few hundred tokens, and both steps ship from the same codebase, a string in a prompt is the correct amount of machinery. The cost curve only bites when outputs are large, the chain is long, or the steps are owned by different teams — at which point the seam deserves a contract. ## What interviewers listen for A weak answer describes chaining as "just passing the output along" and stops. A strong answer prices it: input tokens billed per turn and re-billed as the loop runs, plus the loss of provenance that lets one agent's mistake become the next agent's premise — and then proposes the condensed, named-field handoff as the fix.