The gap between agent demos and agent systems is wider than anything we've seen since the early RAG days. A demo agent books the flight in the happy path; a production agent meets ambiguous instructions, flaky tools, half-authenticated users, and adversarial inputs — at p95, under a cost ceiling, with an audit trail. Here's what has actually survived in our deployments, and what hasn't.
Lesson one: the graph beats the swarm
Free-form multi-agent architectures — agents messaging agents, deciding dynamically who does what — produce mesmerizing traces and unshippable systems. Error compounds across handoffs: three agents at 95% step-reliability yield ~86% before tools fail at all. What survives is the explicit graph: a directed workflow (we use LangGraph) where nodes have contracts, edges have conditions, and the set of possible paths is enumerable. You should be able to draw your agent system on a whiteboard. If you can't, you can't debug it, and you certainly can't put it in front of a compliance team.
Lesson two: most "agents" should be workflows
The honest production question is how much autonomy the task actually needs. Document triage, data extraction, report assembly — these are workflows with LLM steps, not agents. Reserving genuine agency (dynamic tool selection, multi-step planning) for the slice of tasks that needs it cuts cost, latency, and failure surface enormously. Our rule of thumb: if you can write the flowchart, write the flowchart. Agency is for when the flowchart can't be written in advance.
Lesson three: tools fail more than models
In our incident reviews, tool-side failures — timeouts, schema drift, auth expiry, rate limits — outnumber model reasoning failures roughly 3:1. Production agents need what production services need: retries with backoff, circuit breakers, idempotency keys on anything that writes, and a degraded mode for every tool. The model is the most reliable component in most agent stacks. Plan accordingly.
Lesson four: checkpoints are the product
Every consequential action — sending, paying, deleting, filing — sits behind a human-visible checkpoint in our deployments, with the agent's intended action, its reasoning, and a one-click approve/edit/reject. Far from killing the value proposition, checkpoints are what let enterprises deploy at all, and approval data becomes your finest training signal. Autonomy is earned per action type, by accumulated accuracy, not granted by architecture diagram.
Trust in agent systems is built the same way it's built with a new employee: supervised first, autonomous gradually, audited always.
Lesson five: evaluate trajectories, not answers
Single-response evals don't capture agent quality. We eval at three levels: step level (did the node meet its contract), trajectory level (was the path sensible — did it take 4 tool calls or 19), and outcome level (did the task complete to spec). Trajectory regressions — an agent suddenly taking twice the steps after a model upgrade — are invisible to outcome-only evals and ruinous to unit economics.
What this means for your roadmap
- Start with one workflow that has measurable completion criteria and a tolerant failure mode.
- Build the trace/checkpoint/eval infrastructure before adding the second use case — it's reusable; the prompts aren't.
- Budget for tool hardening; it will consume more engineering than the agent logic.
- Treat full autonomy as a milestone you graduate into per action type, with evidence.
Agentic systems are real and the economics can be remarkable — but they're distributed systems with a stochastic component, and they reward teams who respect both halves of that sentence.