The post-mortems are landing
This quarter the reporting finally caught up with the demos. Study after study, echoing the MIT and Gartner numbers everyone quotes, lands on the same ugly fact: the majority of agent pilots never reach production. Not most succeed and a few stall. The reverse. Companies that spent last year building elaborate agent orchestration stacks are quietly killing them. The frameworks cost more to babysit than the humans they were supposed to replace.
If you sat through a slick multi-agent demo in 2025 and walked away with a bad feeling you couldn't name, this is your vindication. You were right. The demo was real. It just wasn't going to survive contact with production, and some part of you knew it.
Let me name the thing you were feeling.
This is not an AI problem
The easy story is that the models weren't good enough. That's wrong, and it lets everyone off the hook. GPT-5.3 and Opus 4.6 are more than capable of doing real work end to end. The models didn't fail. The architecture around them did.
What actually collapsed was complexity debt. Every orchestration layer you add to make a demo impressive is a layer you now have to observe, debug, retry, rate-limit, and pay for. A planner agent hands to a researcher agent hands to a critic agent hands to an executor agent. Five boxes on a slide. Beautiful. Now count the failure modes. Each handoff is a place the context gets truncated. Each agent is a place a hallucination compounds instead of getting caught. Each retry loop is a place your token bill doubles while nobody is watching.
The graph that looked sophisticated in the pitch is the same graph nobody can debug at 2am when the pipeline silently stops producing output. And someone is going to get blamed for that six-figure invoice and the queue full of half-finished tasks. Probably the person who signed off on "more agents means more capability."
That equation was always backwards. More agents means more surface area. Capability and surface area are not the same thing.
What the operators who shipped actually did
Here is the part the vendors selling orchestration platforms will not tell you. The teams winning right now did not build a better agent graph. They deleted the graph.
They took one well-scoped agent and gave it a real workflow to own from start to finish. No planner handing to a router handing to a sub-agent. One agent, one job, one context window, one place to look when something breaks. When it fails, you can read the transcript and see exactly where it went wrong. When it costs too much, you can see exactly which step to trim. When a customer asks what happened, you have an answer.
This is the whole trick. Legibility beats sophistication in production every single time. A system you can reason about at 2am is worth more than a system that wins the demo and dies in the retry loop.
We made this bet early, and we wrote about the shape of it back in AI Deployment: A Game Changer for Small Businesses. The argument then was that pragmatic adoption beats grand architecture. The industry just spent a year and a lot of money proving it the hard way.
Complexity debt behaves like technical debt
If you have shipped software you already know this pattern. You take on debt to move fast. The interest compounds. Eventually the interest payment is the whole engineering budget and no new work gets done.
Orchestration debt is the same, except the interest is denominated in tokens and on-call pages. A single agent that does a plumber's follow-up emails costs you one call to observe and one bill to read. Wrap that same job in a five-agent choreography and you now pay:
- Observability tax. You need traces across every agent boundary or you are flying blind. Most teams discover this after the first silent failure, not before.
- Coordination tax. Agents waiting on agents. Deadlocks. One slow step stalls the whole chain. You built a distributed system and you did not mean to.
- Debug tax. A bug could live in any box or any handoff. The search space is the product of your agents, not the sum.
- Literal compute tax. Every intermediate agent burns tokens reasoning about work the next agent will redo. You pay for the same context three times.
None of that shows up in the demo. All of it shows up in the invoice.
What to do this week
You do not need to rip anything out to test this. Do the audit.
- Draw your current agent flow on one page. Every box, every handoff. If it does not fit on one page, that is your finding.
- Circle the boxes that touch the customer outcome. Usually one or two. The rest are scaffolding you built to make the first version demo well.
- Ask what breaks if you collapse the middle. Give one agent the full context and the full job. Most of the time the answer is nothing breaks and your bill drops.
- Instrument the one path you keep. One transcript, one cost number, one alert. If you cannot explain a failure from the trace in five minutes, the design is still too complex.
- Delete a layer and ship it behind a flag. Watch the numbers for a week. Let the invoice make the argument for you.
Simplicity was never the fallback for when the ambitious version failed. It was the thing that was going to work the whole time. The ambitious version was a detour that happened to look good on a slide.
Where we stand
Hitch runs on this principle, not as a marketing line but as an architecture. One agent named Hank owns a customer's workflow end to end on a single machine, in plain Node, with a database you can query and a transcript you can read. There is no orchestration layer to babysit because we never added one. That was never a limitation. This quarter it turned out to be the point.
If your agent pilot is stalling, the fix is probably subtraction. Start there before you buy another framework.