The Telemetry Gap Between Crash-Free Runs and Actual Agent Correctness
Monitoring must capture tool outcomes independently to detect wrong answers that don't crash.

Silent failure detection for AI agents in production requires telemetry that compares intended behavior with actual execution. A crash-free run establishes execution health. Closing that gap requires independent tool-result capture, step-level traces, and continuous behavioral evaluation that can expose wrong answers even when no exception surfaces.
Why a crash-free run is not a correctness verdict
An agent can return a confident answer after a tool call fails, while its process completes without an exception. Traditional monitoring records that the run finished, how long it took, and that it did not crash. Those observations are accurate but answer the wrong question. They establish whether execution finished, leaving fulfillment of the request and adherence to its governing constraints unassessed. The mismatch reflects incomplete visibility into behavior.
That distinction separates execution health from behavioral correctness. A tool call can complete without selecting the right tool, and a finished task can still depart from its intended goal. Exception-based monitoring has no basis for detecting that departure unless the relevant intent and outcomes are captured. Lowering an alert threshold cannot fill in evidence that was never captured. The instrument measures a different property from the one the team needs to judge.
This leaves a specific gap in production assurance. Engineers can know that the service is available while lacking a signal that its answers are wrong. Fluent output makes the difference harder to spot because it looks like work done well. Yet plausibility does not establish that the underlying tools, decisions, or results support the answer. Correctness requires evidence that ordinary health checks do not collect.
How agents produce success-shaped output from failed reasoning
A tool failure need not stop an agent. The agent can continue from the partial or wrong state available to it, reason forward, and produce a confident response. Retrieval misses and policy conflicts create the same problem when generation continues without resolving them. Fluency survives the failure beneath the answer. Coherence is a property of the generation process.
That continuation can obscure the original failure without any intention to deceive. If tool outcomes reach a log only through the agent’s account, they have already passed through the same reasoning process that produced the answer. The account may describe a coherent route to completion while failing to expose the point where execution diverged from the request.
An external telemetry contract supplies the missing separation. It specifies which state transitions, tool-call outcomes, and decision points must be captured independently of the agent’s narrative. Under that contract, teams can still see a failed tool result even if the final response sounds successful. The distinction is between recording what happened and recording what the agent says happened. Without it, the reporting path can conceal the very evidence needed to diagnose the response.
What failure actually looks like across agent failure categories
Goal deviation, policy conflict, retrieval failure, and incorrect tool selection can each go unseen by exception-based monitoring for different reasons. Their diagnostic evidence sits at different points in the trace. A retrieval miss is a failure in the information on hand when a decision is made, while a tool-selection error is a failure in the choice of action. A single task-level success flag erases those distinctions.
Microsoft AI Red Team’s v2.0 taxonomy names categories including Goal Hijacking, Session Context Contamination, MCP/Plugin Abuse, and Inter-Agent Trust Escalation. These categories widen the scope beyond ordinary execution errors. They concern goals, context, tool trust, and authority between agents. Their trace fingerprints must therefore be sought in the relationship between instructions and actions. A completed operation can be part of a failed task.
For a coding agent, that distinction is concrete. A tool invocation that finishes does not prove that the chosen tool did what the coding task called for. Likewise, correctness depends on whether the tool result supported the claimed outcome. The relevant evidence must connect the requested goal, selected action, observed result, and reported completion.
A June 2026 paper describes silent failures as unexpected departures from intended behavior under normal conditions, without external triggers. Monitoring must therefore detect ordinary behavioral drift as well. Across these categories, the failure lies below the exception layer, where execution can proceed while adherence to the task breaks down.
What these failures cost when monitoring doesn't catch them
An undetected agent error can become a business commitment before it becomes an engineering incident. One AI agent error at a Series B fintech produced $2.1 million in mistaken commitments. The consequence was not merely an incorrect response. The output had crossed into an obligation that should not have been made. A record of successful execution could not distinguish that outcome from an authorized commitment.
Policy drift creates a similar separation between technical completion and business acceptability. An agent can continue producing answers while its behavior departs from the rules it was meant to follow. Inventory errors show the gap in the results of the work, while damage to trust shows up in how people respond to those results. These consequences can become visible in work results and people’s responses after the opportunity to intercept the original decision has passed. By then, diagnosis and remediation concern more than a single run.
Without evidence linking intent to action, the system cannot expose the deviation at the point where it occurs. Damage accumulates while execution still looks healthy.
Why benchmarks don't fill the gap that production monitoring leaves
Benchmarks and evals address a real correctness question. They test whether an agent does what is expected of it under the conditions set by the evaluation. A high score shows how well it did within those bounds. It does not establish that every production decision will satisfy a live request, nor does it explain where a particular run departed from its goal.
UC Berkeley researchers revealed in April 2026 that eight major AI agent benchmarks could be exploited through score computation. Their targets included one agent benchmark, WebArena, OSWorld, GAIA, Terminal-Bench, FieldWorkArena, and another agent benchmark. The exploits achieved near-perfect scores, with 73% on OSWorld, without solving a single task. The scoring path had become detached from the intended work. This is an especially clear demonstration that a success signal depends on what its measurement actually captures.
Even when no one exploits the scoring, aggregate task success can hide a regression. A pass rate can remain flat while tool-selection accuracy deteriorates underneath it. Failure-mode breakdown exposes a different level of behavior. It lets teams distinguish stable overall performance from a weakening component that the aggregate obscures. That distinction becomes essential when the component governs policy compliance or goal adherence.
Production monitoring follows actual inputs, tool outcomes, and decisions along the live execution path as they occur. Benchmarks should retain their role in release evaluation. They cannot replace runtime evidence of whether a particular agent did what a particular request required.
Where MCP and multi-agent stacks create new blind spots in existing telemetry
Multiple MCP servers introduce a correctness question before a tool executes. When mounted servers expose colliding tool names, the model can silently invoke the wrong tool. The invocation may still appear mechanically successful. To detect the error, teams need to track tool-selection accuracy across servers as well as whether a server answered. That is a production signal ordinary execution monitoring does not track.
The Microsoft taxonomy names MCP/Plugin Abuse as a distinct failure mode. Poisoned tool descriptions and server-injected instructions can redirect behavior through trust extended to the tool interface. No exception is necessary for that redirection. The failure occurs in how the agent interprets and follows the material it receives. A successful request to a server does not establish that its influence on the agent was legitimate.
The May 2026 MCP specification release candidate added W3C Trace Context propagation and fixed key names for correlation across SDKs and gateways. This enables a tool call to be followed through the client SDK, MCP server, and downstream services as a single span tree in a compatible tracing backend. That connection is a necessary foundation for diagnosis. It does not, by itself, reveal whether the tool was appropriate or its instructions trustworthy.
The taxonomy’s Inter-Agent Trust Escalation category covers a compromised sub-agent claiming a false identity or higher permissions to an orchestrator that does not check the claim. Downstream failures can then cascade silently through the stack. A connected trace makes the path visible, but correctness monitoring must also capture the authority and intent against which that path should be judged.
What a monitoring layer must capture to see correctness, not just execution
The monitoring layer must capture intent with execution. Correctness is a relationship between what the agent was supposed to do and what it actually did. A record containing only actions leaves that relationship untestable. The required evidence includes the task’s goal and constraints, together with the decisions and outcomes that show whether execution adhered to them.
Step-level tracing is the minimum viable signal. Structured telemetry must cover tool invocations, tool results, plan steps, and reasoning branches. This places evidence at the point of deviation. Tool results must also be captured outside the agent’s own reporting path, so a fluent account cannot replace or mask the underlying outcome.
Detection must extend beyond predefined failure labels. The breadth of agent failure categories makes exhaustive upfront specification unrealistic. A monitoring layer must surface recurring deviations and group them into actionable issues automatically. Otherwise, the system can only find failures the team already anticipated.
Runtime tracing must also feed continuous behavioral evaluation. Evals applied to live traces can expose the gap between aggregate success and deteriorating sub-metrics without waiting for another release gate. Alerts and remediation then need to reach developers in their existing workflow. Evidence that remains in a separate console imposes delay precisely when production requires a fast response.
Closing the gap in practice: what teams shipping agents should do now
Teams shipping or reviewing agents should treat crash-free execution as a baseline and behavioral correctness as a separate requirement. This distinction belongs in release decisions as well as incident reviews. Without it, healthy infrastructure can be mistaken for evidence of faithful task completion. The standard should be whether the agent met its goal within its constraints.
That standard calls for step-level instrumentation from the first deployment. Retrofitting traces after a silent failure is substantially harder than capturing the relevant evidence from the outset. Independent tool-result capture belongs in that initial design. In multi-server MCP stacks, teams should also track how servers behave and how tools are chosen across servers as production signals, because an invocation that seems to succeed can lead to confidently wrong output downstream.
When teams review a regression, they should look at failure modes along with aggregate task success. Tool-selection accuracy, policy compliance rate, and goal adherence should be tracked by trace category. Continuous behavioral monitoring must then operate on production traces, where the input space exceeds what a pre-deployment suite can cover. Waiting for a sufficient test suite leaves that exposure unobserved.
Teams that close this gap can ship agents with greater confidence and remediate failures faster because their telemetry preserves the evidence needed to judge behavior.


