Why Agent Demos Look Impressive and Still Fail in Production
Put two numbers side by side and the gap becomes visible. On the LiveBench 2.0 general task board, Claude Fable 5.2 completes 82.9 tasks and ChatGPT-Pro 4.6 completes 75.6. In a simulated enterprise environment built by
Put two numbers side by side and the gap becomes visible. On the LiveBench 2.0 general task board, Claude Fable 5.2 completes 82.9 tasks and ChatGPT-Pro 4.6 completes 75.6. In a simulated enterprise environment built by infrastructure company EON, the strongest performer — Claude Opus 4.8 — reaches a task success rate of 76.8%.
Those figures are not contradictory. They measure different things. A benchmark score describes the ceiling of a model on a curated task set. A production success rate describes what survives contact with a real operating environment. Teams routinely treat the first as a forecast for the second, and that substitution is where deployment plans break.
This is not a model quality problem. It is a structural problem the entire agent industry faces. Naming it before building anything is cheaper than discovering it after shipping.
The Gap Is a Property of Probabilistic Systems
Demos look good because a demo is a single run, selected for display. An agent is a probabilistic system. Each step carries some probability of failure. Ten steps compound into ten chances to fail. A hundred steps compound into a hundred.
Production, by contrast, accepts a customer base of one million and query volume of a million requests, each of which must be handled. A distribution of outcomes with a one-percent failure rate becomes ten thousand failures. That is not a model defect. It is an evaluation defect. A demo reports the best single outcome. Production reports the whole distribution.
Once that distinction is accepted, the question changes. It stops being "how capable is this agent" and becomes "how often does it fail, and how much does each failure cost when it does." Those are two different questions, and the second one is rarely asked.
Current leaderboards are honest about what they measure: the ceiling. Almost nobody publishes what happens at the floor. Yet the floor is what determines whether a deployment survives its first month.
Agents also have two cost structures running simultaneously: the compute, tokens, and latency incurred during a run, and the labor spent reviewing outputs and repairing damage. Benchmark tables report the first. Production teams pay both. An agent that scores well but requires human review on every third output is not a productivity gain. It is a workflow with an unmeasured second shift.
Recognizing this is where genuine agent engineering begins. Every claim about agent capability that does not come with a failure distribution is marketing collateral, not evidence.
Three Failure Modes Seen in Production
TechCrunch published three recurring failure modes on November 11. Each is worth recording separately, because each requires a different fix.
Early termination. An agent stops before the task is complete, and treats an intermediate state as a finished product. The reported case involved an agent that mistook a customer's waiting page for the completed deliverable and submitted it. No error was raised, because none of the intermediate steps violated a rule. Each step was locally valid. The task was simply declared finished too soon.
Silent substitution. When an intermediate step fails, the agent does not report the failure. Instead it continues execution using the closest available substitute, and returns a result without any accounting of what was replaced. The final output looks normal. The contamination stays invisible. Downstream consumers inherit a result assembled from parts that were never confirmed.
Context collapse on long tasks. As conversations lengthen and tool calls accumulate, an agent drifts at some point and loses the thread. Output quality degrades from there onward. The failure is not a crash. It is a gradual loss of coherence that produces fluent, incorrect work.
These three share a property: none of them appear on a standard benchmark. Single-turn capability, isolated tool competence, and per-step accuracy are all preserved while the composite task fails. A benchmark scoring one step at a time cannot detect a failure that only exists across steps.
The more realistic the scenario, the more reliably all three occur together. A long conversation combines multiple rounds of dialogue with tool constraints that cannot all be satisfied. What looks like "poor capability" is usually a composite of three distinct defects. Production failures are rarely caused by one weak component. They are usually several components that each work in isolation and combine badly.
Digital Twins Push the Company Into the Test Environment
Plural recently raised a $13 million seed round with an eight-person team. Its product is a digital twin of the enterprise: a simulation of a company's knowledge base, tools, and interfaces, assembled so that an agent can be evaluated against something that resembles the environment it will actually operate in.
This is a step past conventional agent evaluation. It no longer asks whether an agent can complete a task. It asks whether the agent can produce an output the customer accepts, inside the customer's own operational constraints. Permission boundaries, data visibility, interface behavior, and response delays all become part of the test.
The premise is aggressive but defensible. No simulated environment can fully reproduce a real business. The more practical goal is narrower: reproduce the failure modes that actually occur, at a cost the customer is willing to pay. Simulating every edge case is infeasible. Simulating the failure classes that already appear in production logs is tractable.
This kind of platform does not compete with existing tooling. Claude Code, Codex, Copilot, and Cursor all continue to work. The evaluation layer does not replace the agent; it tests the agent. For engineering teams, that is the relevant framing: the evaluation environment is capital infrastructure, not a feature of the product. No real production deployment should be certified against an unfixed baseline.
Digital twins add one property that benchmark suites cannot offer: rollback. When production breaks, the state at the moment of failure is replayable in the simulation. The debugging question becomes "which step diverged" rather than "somehow it went wrong again."
Autonomous Driving Already Paid This Tuition
Both Plural co-founders, Ilian Kadar and Edd Lovi, came out of the autonomous driving industry. Kadar previously worked at Nexar and Waymo on simulation and training for driving systems. Both describe the move into agents as a change of domain rather than a change of problem.
Kadar's summary is direct. Autonomous driving looked exactly like the agent industry does now. Making a demo was easy. Delivering something repeatable and shippable was hard. Early self-driving demos ran in parking lots without a single accident. Once the same system moved onto public roads, the failure rate exceeded what any release process could absorb.
The industry's response was not better demos. It was simulation: build the environment first, then evaluate the system inside it. Real-world data covered a vanishingly small share of the scenarios that mattered; simulation made the remaining cases reproducible. Autonomous driving spent roughly twenty years learning how to validate a probabilistic system before deploying it at scale. The agent industry is at the same template now.
The forms of evaluation rhyme: simulated environment, composite tasks, upgrades to the model itself. The difference is that agent environments are far more diverse, and far more numerous per unit of work.
What autonomous driving also demonstrated is that education by example is expensive. Very few people in that industry could explain why a particular metric mattered. Millions of kilometers accumulate into a single number, and the number no longer carries information that changes a decision. The first time anyone asks which metric is meaningful, that metric already has information content. Autonomous driving spent years and a lot of capital learning that. Agent teams can read the lesson or repeat the tuition.
Choosing not to build an evaluation baseline means choosing not to verify anything.
A Success Rate Number, On Its Own, Explains Nothing
A figure like 76.8% should immediately raise the question of sampling error. One hundred tasks with 76 successes and ten thousand tasks with 7,600 successes are two different claims. Neither is a statement about capability without an interval.
The standard method for quantifying that uncertainty is a confidence interval. Wilson's interval is the standard tool here. It produces a range instead of a point.
import math
def wilson_interval(k, n, z=1.96):
if n == 0:
return (0.0, 0.0)
p = k / n
d = 1 + z**2 / n
center = (p + z**2 / (2*n)) / d
half = (z * math.sqrt((p * (1 - p) + z**2 / (4*n))) / n) / d
return (center - half, center + half)
lo, hi = wilson_interval(76, 100)
print(f"{lo:.3f}, {hi:.3f}")
Run this and the 76.8% figure comes back as roughly 0.73 to 0.82. At a 95% confidence level, the interval spans from about 73.0% to 81.9%.
That interval is more useful than the point estimate. It is also what a 76.8% number conceals when reported alone.
The practical implication is immediate. If a vendor reports a success rate without sample size and without an interval, the number cannot be used to predict your own deployment. A team running 100 tasks and a team running 10,000 tasks face different failure budgets. A single rate flattens that difference into a false equivalence.
A useful rule follows: an interval narrows only when the success rate approaches saturation and the sample is large. Anything short of both leaves a wide band, and a wide band means the deployment decision is still open.
The Business Behind the Simulated Environment
The commercial logic is visible in Plural's pricing model. Billing is per simulation-environment invocation, and each customer's environment is trained against its own historical data. Testing with NVIDIA and Nebius indicates that these customer-specific models outperform general-purpose baselines.
The reason is structural, not adversarial. A simulation environment can only be validated by the customer's own data. Once it is, the tuned model is transferable to the customer's live environment. Without that data, only a general foundation is available to transfer.
Cost sensitivity is high, and it cuts in the platform's favor. Running a task in simulation costs far less than running the same task against live production systems, where a failure has real consequences. The economics of training against a twin are favorable precisely because the alternative is expensive.
For customers, the model also changes commercially. What is being sold is not the strongest model available. It is a model narrowed to your own failure distribution. Once the evaluation pipeline is validated and the tuned model is in place, the agent economy's cost structure shifts: simulation replaces much of the trial-and-error that would otherwise happen in production.
The path is still costly for engineers and teams running it. Building a small evaluation environment demands real effort on its own, and the training data must come from the customer's own environment. The sequence — data, evaluation, training, delivery — means the whole cost is not conversion cost but infrastructure cost. Once that infrastructure stands, conversion becomes much cheaper and more repeatable. That is the characteristic shape of simulation.
Minimum Viable Agent Health Check
Everything above reduces to three actions for a team that wants to test its own agent.
First, list the twenty most-used pages or workflows in your actual business. Not the twenty cases in a benchmark suite. The twenty paths your users traverse most often.
Second, label three hundred examples by hand and compute an interval, not a rate. Three hundred is the minimum sample at which an interval begins to carry information; the code above will do the arithmetic.
Third, sort the failures into classes and build a repair roadmap. Failure type matters more than frequency. A premature stop and a silent substitution require different fixes even when their rates are identical. Labeling the failure class is the step where remediation actually starts.
Here is the comparison of the three evaluation tiers.
| Evaluation tier | What it simulates | What it can detect | What it cannot detect |
|---|---|---|---|
| Public leaderboard | A general-purpose task set | Ceiling of general capability | Anything specific to your environment |
| Simulated enterprise | A standard, generic company | Approximate performance on composite tasks | Real user behavior, real data distributions |
| Digital twin | Your own historical data | Fidelity of the real operating environment | Delivery quality, model generalization |
The three tiers are sequential, not alternatives. A leaderboard tells you which model to start with. A simulated enterprise environment tells you roughly how it composes. A digital twin tells you whether it survives your own business. Each depends on the one before it.
A short-time, low-intensity check is worth doing before the final decision. Once a baseline harness exists, a three-to-five day iteration is enough to establish the first reliable baseline. Without it, three years of accumulated production experience still leaves no answer to "which step failed first." Build the baseline first, then improve the product. That sequence is worth repeating.
What to Do About Failure Distributions
The gap between a demo and a production run is not a phase the industry passes through. It is the shape of probabilistic systems operating under repetition. Two consequences follow from accepting that.
The first is that evaluation shifts from capability to reliability. Capability is a ceiling, measurable once. Reliability is a distribution, measurable only over volume. Teams that instrument their own failure classes accumulate an asset that cannot be copied from a leaderboard.
The second is that model selection becomes a per-workload decision rather than a single commitment. A 76.8% rate with a [73, 82] interval precedes the question of whether that rate is acceptable for a given workflow. An internal research assistant tolerates a 20% failure rate if every output is reviewed. An action-taking agent that writes to production systems does not. The same number supports opposite decisions depending on where it lands.
Routing different workloads to different model endpoints is one way to hold that distinction operationally rather than by convention. 4sapi provides centralized model access, so an application can send high-volume, low-consequence tasks to a cheaper model and gate irreversible actions behind a more reliable one, without maintaining a separate integration per provider. The configuration lives in one place rather than scattered across client code.
Start with twenty workflows, three hundred labels, one interval, and a failure taxonomy. That is a smaller commitment than a full deployment plan, and it produces the only number that survives contact with production.
International access: https://4sapi.com
Domestic access: https://4sapi.org
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.