The Failure Mode Nobody Benchmarks

Most agent evals measure success. The ones that matter measure how systems fail.

I've been running multi-agent pipelines in production long enough to recognize a pattern: the agents that look impressive in demos are the same ones that silently corrupt your data at 3 AM. The gap isn't in capability—it's in how systems behave when they hit the edge of their competence and keep going anyway.

This is why the VAKRA benchmark from IBM Research and Hugging Face caught my attention. They didn't just test whether agents can complete tasks. They categorized failure modes across reasoning hierarchies, tool misuse, and what they call "premature termination"—agents that decide they're done when they absolutely are not.

The Three Failure Archetypes

Production agents fail in predictable ways. I've seen them all:

Reasoning collapse happens when an agent's confidence outpaces its actual understanding. The model generates a plausible-sounding plan, executes it flawlessly, and produces completely wrong output because the initial reasoning was flawed. Standard benchmarks reward completion, so agents learn to complete things—even incorrectly.

Tool superstition is what I call it when agents develop cargo-cult relationships with their tools. They call APIs in patterns that worked once, retry failed operations with identical parameters, or chain tools in sequences that resemble successful past runs without understanding why. The VAKRA data shows this is rampant—agents repeating tool calls that returned errors, hoping the next invocation will magically succeed.

Context abandonment might be the most insidious. Agents start with a clear goal, accumulate context through multiple steps, then gradually drift from the original objective. By step twenty, they're optimizing for something entirely different than step one. Without explicit goal-state verification, nobody notices until the final output is reviewed.

Why Harness Design Matters More Than Model Choice

The community is finally waking up to what practitioners have known: the scaffold around the model determines reliability more than the model itself. VAKRA's results show that even capable models fail catastrophically without proper harness design—explicit verification steps, tool output validation, and reasoning traces that can be audited.

I've rebuilt agent harnesses four times across different projects. Each iteration taught the same lesson: the hard part isn't calling tools. It's knowing when to stop, when to ask for clarification, and when to escalate to human oversight.

Notion's team described this well in a recent discussion about their custom agents. They spoke of "frontier evals"—test cases they expect to pass only 30% of the time, not because they're satisfied with low performance, but because those failures reveal where models are actually heading. This is the right mindset. You don't benchmark for today's capabilities. You benchmark to understand tomorrow's failure modes.

The Cost of Silent Failures

In RAG pipelines, a failed retrieval is obvious—you get no context. In agent systems, failure masquerades as success. The agent returns a result. It looks structured. It follows the expected format. But the data is wrong, or the analysis missed critical constraints, or the tool call modified the wrong record.

These failures don't show up in accuracy metrics because the system technically completed its task. They show up in downstream systems, in customer complaints, in data corruption that takes hours to unwind.

VAKRA's taxonomy helps here. By explicitly categorizing failure types—reasoning errors, tool misuse, early termination—they give engineers a vocabulary for what to guard against. You can't build verification for "bad output." You can build verification for "tool returned error but agent proceeded anyway" or "final answer doesn't address original question."

Building for the Edge

The agents that survive production are the ones designed with failure in mind. This means:

Explicit verification gates after each major operation, not just at the end. Did the tool call actually modify what we expected? Does the intermediate result make sense given the inputs?

Confidence thresholds that trigger escalation, not just low-confidence paths that proceed anyway. If the model is less than 80% certain about a critical decision, human review isn't overhead—it's architecture.

State snapshots at each step so failures can be replayed and diagnosed. The agents that are hardest to debug are the ones that run in black boxes, leaving only final output and no trace of how they got there.

Tool contracts that specify not just what tools do, but what they return in failure cases. Agents need to understand that "error" is a valid output that requires handling, not just a signal to retry blindly.

The Real Benchmark

The agent ecosystem is maturing past the demo phase. We're moving from "watch it work" to "trust it to run unsupervised." That transition requires a different engineering mindset—one that assumes failure is the default state and builds systems that fail visibly, recover gracefully, and never silently corrupt.

VAKRA won't be the last benchmark focused on failure modes. It shouldn't be. Until we treat agent reliability as a first-class concern—measured, benchmarked, and engineered for with the same rigor we apply to model capabilities—we're building systems that work until they don't, spectacularly, at the worst possible moment.

The agents that will dominate production aren't the ones with the highest success rates on clean benchmarks. They're the ones that fail in predictable, recoverable ways when the real world gets messy.