The Agentic Harness

How Silent Tool Failures Cascade Into Corrupt Orchestrator State Across Agent Handoff Boundaries

Silent tool failures propagate through agent handoffs without detection.

· 9 min read
Cover illustration for “How Silent Tool Failures Cascade Into Corrupt Orchestrator State Across Agent Handoff Boundaries”
Agent Failure Diagnosis · November 5, 2026 · 9 min read · 1,982 words

To detect silent tool failures in production multi-agent pipelines, checks for whether the tool raised an error must be paired with tracing a returned value through the orchestrator’s decisions, memory writes, and handoffs. A plausible but wrong return can become shared state before any component reports a fault. The repair surface is the harness, where outcome contracts can expose bad returns and pre-execution gates can stop policy-violating writes.

Why tool failures in LLM agents are silent by design, not by accident

Traditional software exposes failures through exceptions, stack traces, and circuit breakers. LLM agents have no native exception boundary between a tool’s returned value and their own reasoning. If a malformed result arrives in the expected format, the agent can consume it as fact. The call appears to have completed normally. That leaves the reasoning loop without the signal that would ordinarily trigger a pause or recovery path.

The agent’s task is to reason forward from observations, but it has no independent ground truth against which to validate every observation. A negative price, a cached error page, or a currency-mismatched figure can therefore follow the same path as a correct return. Format alone does not establish semantic validity. The raw loop provides no separate mechanism that reliably marks a wrong result as wrong.

Wu 2026 documents this gap in a continuously operating production runtime. Over an eight-week window, its 4,286 unit tests and 827 declarative governance checks stayed green through most incidents. The study names the worst class Class D, or “fail-plausible,” where polluted context becomes fluent, coherent output delivered as a confident finding. In one incident, a cached HTTP 400 error page became a fabricated industry analysis about a “Hugging Face platform crisis.”

How a single malformed result propagates through an orchestrator's reasoning chain

Once a malformed result enters the context window without a warning, it becomes an authoritative input to subsequent reasoning. The first propagation leg is the immediate decision. The orchestrator bases a plan or comparison on the wrong value, so the next step can make sense on its own while already straying from the task’s actual conditions. A currency-mismatched figure, for example, can produce a misleading comparison without causing a parsing or execution error.

The second leg is persistence through memory writes. If the orchestrator records the value as intermediate state, later steps can inherit the error without repeating the original tool call. The corruption now outlives the observation that introduced it. This separates the later symptom from its source, because a memory read can look like an ordinary use of established context even when that context came from a bad return.

The third leg passes the error into downstream tool calls. Parameters derived from corrupted state can be well formed, allowing subsequent tools to execute faithfully while compounding the original mistake. The currency example ends with a confident wrong summary after a misleading comparison, with no error raised at any stage.

Panthi and Abdelfattah 2026 identify two reasoning problems within this chain, spotting an observation that does not fit and choosing a recovery action. Their proposed external outcome monitor assists with those problems rather than assuming unaided reasoning will resolve them. Detection must come before an informed recovery choice. Without it, the orchestrator has no reason to treat its next decision, memory write, or tool invocation as part of a failing trajectory.

Why the handoff boundary turns a local corruption into a system-wide one

A handoff compresses the orchestrator’s accumulated state into a summary, structured payload, or task description. The receiving subagent treats that artifact as shared ground truth without access to the upstream trace that produced it. Compression can drop rules, permissions, and uncertainty signals that came with the original observation. The conclusion travels without its supporting evidence.

Each handoff adds a probabilistic failure point, so high reliability at individual agents does not imply equally high end-to-end success as handoffs accumulate. Fan-out extends the damage beyond a single sequence. An orchestrator that passes one corrupted value to three specialized subagents can receive three independently reasoned but jointly wrong outputs, each elaborating the same faulty premise.

Wu locates the longest-lived silent failures in seams between components, where no test ran by construction. Those incidents persisted for days or weeks rather than appearing as immediate component failures. A handoff is precisely such a seam. The receiving subagent has no way to know that the upstream state was wrong when its only evidence is the corrupted artifact itself.

The three harness layers where silent failures most commonly originate

Tool schema, prompt termination logic, and workflow routing provide a practical taxonomy for locating the origin of a cascade. These are harness failures. In tool schema drift, the harness is built against one version of an interface while the tool evolves. A return can remain syntactically valid even when a type mismatch changes its meaning. A description mismatch can be worse, because it causes the model to call a tool in the wrong situation or omit it when needed without producing a runtime error.

Prompt ambiguity creates a different failure pattern. A goal without a verifiable done-condition gives the agent no clear signal that the task is complete. The agent may keep retrieving, synthesizing, or appending output, and each new tool call gives a malformed return another chance to enter a context that is already long.

Workflow routing controls whether a path that fails can change course. An agent in a retry loop can issue the same failing call repeatedly when the workflow provides neither failure recognition nor an alternative route. These patterns can overlap within one incident. Schema drift can let in a silent wrong return while the lack of a termination condition keeps execution running until it hits a resource limit.

Suresh Babu and Agrawal 2026 frame orchestration reliability as a runtime control problem. The orchestrator must observe execution, detect failure signals, and classify likely causes before it can choose a useful response. That requires signals the harness actually exposes. The taxonomy therefore locates more than faulty instructions or interfaces. It locates the places where execution can lose the information needed to control itself.

How do you know a tool failed silently? The orchestrator's trace is the only honest witness

Unit tests and health checks can establish that individual components work without establishing that their interaction is sound. A silent cascade lives in that interaction. A tool may return successfully, a memory write may complete, and a subagent may finish its task while the run as a whole gives a wrong answer.

Wu reports a zero percent ex-ante prevention rate for the studied runtime’s declarative governance layer across the documented incidents. The same layer was useful for blocking regressions afterward, but it did not predict or prevent those failures before they occurred. This is a specific evidentiary limit. The missing evidence was the failing interaction itself.

A full span-attached production trace records the tool call, its return, the orchestrator’s subsequent use of that return, and what it wrote to memory or passed forward. That sequence makes causal reconstruction possible. Logs containing only initial inputs and final outputs leave the intermediate dependencies unresolved. Because LLM failures are non-deterministic, repeating those inputs does not reliably reproduce the same trajectory, so the original trace is essential evidence.

Attributing a failure to the layer that caused it, not the layer where it surfaced

The visible symptom usually appears downstream of the initiating fault. A wrong final response may suggest a model problem even when a tool supplied a malformed value three steps earlier and the model reasoned faithfully from it. In that case, the repair belongs in the tool schema or the validation gap before reasoning. Attribution must follow the dependency graph upstream to find the cause, since the affected nodes may share a failure.

Reddy, Challaram, and Basu 2026 demonstrate a related attribution problem in the τ²-bench airline domain. Their study found that 78% of observed failures were silent wrong-state failures with no tool error. Tools accepted policy-violating calls because the policy existed only in a natural-language prompt. Execution succeeded while the intended constraint failed. Identifying the cause required knowing where the policy was supposed to be enforced.

Before a repair, the minimum diagnostic resolution consists of six answers. The responsible layer must be identified as prompt, tool, workflow, memory, model, or product logic. The trace must locate the step where corruption entered and distinguish downstream reasoning from wrong input from additional independent errors. Attribution must also establish whether the incident is isolated or recurring, whether the same root cause explains other incidents, and what a targeted fix needs to change. Without that resolution, a repair can address the symptom while leaving the initiating fault intact.

Intercepting the cascade before it crosses a boundary: outcome contracts and pre-execution gates

The intervention points follow directly from the propagation chain. Outcome contracts check returned values before they enter reasoning, while pre-execution gates check proposed calls before tools write. These mechanisms address different directions of travel. The former exposes silent bad input. The latter prevents a proposed action from silently producing forbidden state. Both work in the harness without the need for model retraining.

Panthi and Abdelfattah introduce Outcome Monitors as deterministic detectors built around invariants mined from task-disjoint traces or derived from public schemas. On a violation, a monitor issues an advisory receipt naming the violated property and listing available recovery tools. It does not restrict actions or choose the repair. Detection remains separate from recovery, with the agent deciding what to do after receiving a signal the raw loop would otherwise lack.

The study reports large gains in completion on ToolMaze across multiple model families and gains across two task tiers on τ-bench retail. Most of those gains come where the fault kept the baseline from completing the task. Coverage remains a genuine engineering constraint, however. Detection falls significantly for incidents outside the mined contract vocabulary, so a monitor cannot be treated as a general validator for every plausible wrong return.

Reddy and colleagues test deterministic, read-only gates that check a proposed tool call and the current database state before they allow a write. Their four-gate suite raises full-benchmark success by 12.4 percentage points on gpt-4o-mini, with the lift replicating on a disjoint seed set. One drove nearly all the gain at high precision, while another had very low precision, making per-gate precision audits necessary to expose false positives.

Deployment therefore depends on the enforcement gap. Gates help where tools accept well-formed calls that break policies found only in prompts, but add little where tools already enforce their own preconditions. Outcome contracts require comparable attention to coverage. Neither mechanism removes the need for diagnosis. Trace-based attribution identifies which boundary needs intervention and which constraint the intervention must test.

Turning production traces into a systematic improvement loop, not a postmortem archive

When traces are collected but never studied in a systematic way, the system is left reacting to failures. The same failure class can recur until the evidence drives a change at its source. Detection, repair, and validation need to form one closed loop. Detection locates the broken run and responsible layer, while repair targets that layer through a tighter schema, a termination condition, an outcome contract, or a corrected tool description.

Validation then replays the proposed change against the historical traces that exposed the failure. It must show that the change fixes the documented cases without causing regressions on traces that were clean before. Wu reports an 87% ex-post regression-blocking rate for the same declarative governance layer that had prevented none of the documented incidents in advance.

The system can again look healthy under checks that do not observe the corrupted output or the path that produced it. Trace, attribute, repair, and validate form a repeatable reliability discipline. Its distinguishing features are non-deterministic production evidence, a harness-level repair surface, and trace replay as the test of whether the repair addresses the actual failure.

Sources

  1. When Errors Become Narratives: A Longitudinal Taxonomy of Silent Failures in a Production LLM Agent Runtime
  2. Outcome Monitors: Recovery Affordances for Silent Tool Failures
  3. Reason Less, Verify More: Deterministic Gates Recover a Silent Policy-Violation Failure Mode in Tool-Using LLM Agents
  4. Self-Healing Agentic Orchestrators for Reliable Tool-Augmented Large Language Model Systems

More in Agent Failure Diagnosis