An agent booking a trip across five tools in a two-minute demo is genuinely impressive. Run it 1,000 times against real inputs and it will silently pick the wrong flight, loop on an ambiguous form, or reconcile an invoice to the wrong vendor. The demo optimizes for the happy path; production is 90 percent edge cases. Our position: narrow, tool-using agents on bounded tasks are real and shipping value now, while open-ended autonomous agents remain theater for anything consequential. The dividing line is not model capability. It is the cost of a wrong action and your guardrails.
The demo is not the product
An agent booking a trip across five tools in a two-minute demo is a genuinely impressive artifact. The same agent, run 1,000 times against real inputs, will silently pick the wrong flight, loop on an ambiguous form, or confidently reconcile an invoice to the wrong vendor a meaningful fraction of the time. The demo optimizes for the happy path. Production is 90 percent edge cases. In 2026 a large share of enterprise "agent" budgets will be spent closing that gap, and much of it will be wasted because teams bought the demo, not the operating requirements behind it. The demo answers the question can it do this once. Production answers the question can it do this 10,000 times without a wrong action that costs more than the whole program saved. Those are different questions, and vendors are incentivized to answer only the first. The gap is widest exactly where the demo is most seductive, on open-ended tasks that look magical in two minutes and become unmanageable at scale.
Our position is deliberately narrow. Agentic AI is real and shipping value today for bounded, tool-using tasks where a wrong action is cheap to catch and cheap to reverse. It is theater, still, for open-ended autonomy over anything consequential, because the failure modes are not rare enough and the guardrails are not mature enough. The decision rule is not "how smart is the model." It is "what does one wrong action cost, and can I detect and undo it before it matters." A brilliant model wired to an irreversible action with no checkpoint is more dangerous than a mediocre model wired to a reversible one, because the failure lands where you cannot take it back. Capability raises the ceiling on what agents can do; it does nothing to lower the cost of the mistakes they will still make.
Deploy the bounded, wait on the autonomous, ignore the swarm
Sort every proposed agent by two axes: how reversible a wrong action is, and how much a human still has to review. The real category is high-reversibility, human-checkpointed work. The theater category is low-reversibility autonomy sold as hands-off.
| Use pattern | Verdict | Why | What to require |
|---|---|---|---|
| Drafting and summarizing with a human approver | Real now | Wrong output is caught before it ships; cost of error near zero | Provenance on every draft; approval gate |
| Retrieval and research over your own corpus | Real now | Grounded, citable, reversible; agent proposes, human decides | Source citations; no answer without retrieval |
| Bounded workflow automation (triage, routing, reconciliation flags) | Real with rails | Narrow scope, defined inputs and outputs, easy to audit | Confidence threshold; escalation on ambiguity |
| Autonomous multi-step actions on money, contracts, prod systems | Wait | Low reversibility; error rate still too high for hands-off | Human-in-the-loop; hard action limits |
| Fully autonomous "agent swarms" running the business | Ignore for now | Compounding error, no accountability, unauditable | Not production-ready at any consequential scale |
A concrete illustration: a finance team piloted an agent to code and post journal entries end to end. On a 500-entry test set it was 96 percent accurate, which sounds excellent until you price the 20 wrong postings, each requiring a reversal, an audit note, and a control exception. They rescoped the agent to propose entries and flag anomalies, with a human posting. Throughput rose 3x, and the error cost went to near zero because nothing hit the ledger unreviewed. Same model, same accuracy, opposite outcome, because the design respected the cost of a wrong action. The lesson generalizes: the value was never in removing the human, it was in removing the human from the parts of the task where a mistake is cheap while keeping them exactly where a mistake is expensive. Teams that internalize this stop asking how autonomous can we make it and start asking where can we safely let go.
Buy operating requirements, not demos
If the position is right, the practical implication is that your agent roadmap should be organized by reversibility and auditability, not by how autonomous something can be made to look. Fund the boring, bounded agents that draft, retrieve, triage, and flag, and put a human approval checkpoint on anything that touches money, customers, or production. Treat any vendor pitch that leads with full autonomy over consequential actions as a red flag: ask for the error rate on a realistic test set, the reversal cost per error, and the audit trail. If they cannot produce all three, you are being sold theater. The teams that win in 2026 will look less impressive in the demo and far better in the quarterly close.
The failure patterns to expect
- Buying autonomy you cannot audit: an agent takes 12 steps and you can inspect none of them, so when it errs there is no trail to explain what happened or why.
- Confusing demo accuracy with production accuracy: 96 percent on the happy path becomes 80 percent on real inputs, and the 20 percent lands on your most expensive edge cases.
- Skipping the reversal-cost math: a 4 percent error rate is fine for draft emails and catastrophic for wire transfers, yet teams apply one threshold to both.
- No confidence gating: the agent acts with the same certainty when it is sure and when it is guessing, so ambiguous cases get committed instead of escalated.
- Removing the human too early: the checkpoint is cut to show ROI, the first bad action ships to a customer, and the whole program loses trust overnight.
Screen your agent backlog this week
- Tag every proposed agent as high or low reversibility, and require a human checkpoint on all low-reversibility work.
- Demand an error rate on a realistic 500-case test set, not a demo, before funding anything.
- Price the cost of one wrong action per use case and set the automation threshold from that number.
- Require provenance and citations on every consequential output; no black-box actions.
- Add confidence-based escalation so ambiguous cases route to a human instead of being committed.