AgentsChecked. KNOW WHICH STEP BROKE YOUR RUN

FIELD GUIDE 01 — FAILURE PATTERNS

Handoff failures: how AI agent runs actually break

When a multi-agent run goes wrong, it almost never crashes. Every step returns success. The final answer is fluent, confident — and built on a value that changed somewhere in the middle, in a pass between two agents that nobody was watching. The failure lives at the seam, and seams are exactly what step-by-step logs don't show you.

These are the failure classes we see when we reconstruct runs seam by seam. Every one of them is invisible from inside any single step — each agent did something locally reasonable with what it received. You can hunt for all of them by hand with the audit checklist, or run them automatically: the free audit checks a pasted trace against every class below.

The value changed in transit

The most direct family. A field leaves one step holding one thing and arrives at the next holding another — and downstream steps trust the arrival, not the departure.

CHANGED AT THE SEAM

  • Value mutated — same field, different value on the far side. A decimal walks (184.00 becomes 184000), a currency rule rewrites a number, a sign flips.
  • Type changed — the value survives but its shape doesn't: a number arrives as a string, an object as a scalar, and the next step's comparisons quietly mean something else.
  • Arrived null — the sender produced a real value; the receiver got null or an empty string, and proceeded as if "no value" were a fact about the world.

The value never arrived

Nothing errors when a payload shrinks. The receiver works with what it got — and what it got is a subset, treated as the whole.

LOST AT THE SEAM

  • Field dropped — fields the sender produced are absent from what the receiver got. Usually a hand-rolled mapping that only carried the fields someone remembered.
  • Empty payload — the sender produced fields; the receiver got nothing at all, and the run continued anyway.
  • Payload truncated — the received payload is a fraction of what was sent, with fields missing: the signature of a cut-down extract passed off as the full record.
  • Schema / key mismatch — the two sides of the seam barely share any keys. They weren't talking about the same shape of data at all.

The value appeared from nowhere

The mirror image: the record gains facts nobody produced. These are the failures that survive code review, because the output looks complete.

UNSOURCED

  • Field invented — a field enters the record untracked at a seam: present in what the receiver holds, never sent by anyone.
  • Final value with no source — a field in the run's final output that no earlier step produced under that name with that value. The answer exists; its provenance doesn't.

The chain itself broke

Sometimes every value is fine and the structure is the lie: the declared flow of the run doesn't match what the record shows.

STRUCTURAL

  • Unresolvable reference — a step declares its input came from a step that doesn't exist in the run. Its provenance is a claim that can't be checked.
  • Output never consumed — a step produced work that no later step ever used. Dead effort in the middle of the chain, often a sign the run took a different path than its design.
  • Reviewer checked the wrong source — a review or validation step verified a value that differs from the value at the origin of its own declared source chain. It checked a mutated copy and signed it off.

The agents disagreed, or spun

CONTROL

  • Unresolved disagreement — two agents independently asserted different values for the same field, the conflict reached the final output, and no step ever resolved it. The run picked a winner by accident.
  • Retry / loop storm — the same work keeps bouncing: an agent or handoff repeats with substantially the same payload instead of the work moving on. Repetition with different payloads is a queue; repetition with the same payload is a loop.

One step ate the run

OUTLIERS

  • Cost outlier — one step cost at least five times the median step in the same run.
  • Duration outlier — one step took at least five times the median duration. Outliers are judged against the run's own distribution, not a global threshold — a run tells you what "normal" was.

Why your logs don't show you this

Logs are written from inside the steps. Each entry is honest about what that step saw — and the failure is precisely what no step saw: the difference between what one step emitted and what the next received. To see it you have to reconstruct the run as a chain of handoffs and diff every seam: fields sent against fields received, values out against values in, final outputs against everything that supposedly produced them.

That reconstruction is what BlameGraph does. It is also older than agents: the documented cases on our homepage — a field-count mismatch that crashed 8.5 million machines in the 2024 CrowdStrike outage, a repurposed flag at Knight Capital in 2012, a chatbot inventing policy at Air Canada — are the same classes, in chains of automated handoffs that predated LLMs. Agents have made the chains longer, faster, and harder to watch. They did not invent the failure.

Every class above is one of the 16 checks the audit runs — on your trace, not a demo.

RUN THE FREE AUDIT →