Agent orchestration failure modes: silent drift, reconciliation, and the supervision mindset shift
The Failure Mode Nobody Is Logging
Most production AI systems don’t fail loudly. They don’t throw exceptions, trigger alerts, or produce obviously wrong outputs. They drift. Quietly, confidently, step by step, until you’re ten downstream tasks deep and the original intent is completely unrecognizable. I’ve been running multi-agent pipelines for over a year, and this pattern has burned me more than any bug I’ve ever debugged in traditional software.
Let me explain what I mean, and why the Boris Cherny Claude Code thread made me stop and think harder about it.
Silent Drift and the Confidence Problem
Here’s the core issue. Agent A finishes a task and passes its output to Agent B. Agent B has no memory of what Agent A was actually asked to do. It just sees output, treats it as ground truth, and builds on top of it. If Agent A was subtly wrong, Agent B doesn’t push back. It accelerates.
I call this silent drift. Not a crash. Not even a warning. Just forward momentum in the wrong direction, compounding with every hop.
The reason this is so dangerous is that LLM outputs look authoritative. The prose is clean, the structure is logical, the confidence is implicit. Nothing about the output signals “this is where the error was introduced.” You have to go looking for it, and most pipelines aren’t built to look.
Why Boris Cherny’s Thread Hit Different
When Cherny dropped his Claude Code feature breakdown, the reaction was immediate. Rohit’s amplification thread put it plainly: most people using Claude Code are at maybe 30% of its actual capability.
Git worktree parallelism. Fan-out across hundreds of agents simultaneously. Scheduled automation loops. Hooks into the agent lifecycle. These are genuinely powerful primitives. I’m not dismissing them.
But here’s what I kept thinking as I read: each one of those features is a multiplier. Fan out to a hundred agents and you’ve also fanned out any error in your initial context a hundredfold. Scheduled automation loops mean drift can run unattended for hours before a human sees it. Parallelism without reconciliation is just parallel wrongness at scale.
Power without observability is not a feature. It’s a liability with a great demo.
The Reconciliation Gap
What most orchestration frameworks still lack is a real reconciliation layer. By reconciliation I mean: a formal step where downstream agents don’t just consume upstream output, but validate it against the original task specification. Did this output actually answer what was asked? Does it contradict something established earlier in the pipeline? Is there a confidence threshold that should gate further execution?
Right now, most teams handle this with prompting. “Double check the previous step before proceeding.” That’s not reconciliation. That’s a prayer.
Real reconciliation needs to be structural. A separate validation agent with no access to the producing agent’s reasoning, just the spec and the output. Hard stops when outputs fall below a similarity threshold to the original goal. Audit logs that show not just what each agent produced, but what it was handed to start with.
This isn’t exotic. It’s just software engineering applied to a domain where people keep forgetting to apply it.
The Supervision Mindset Shift
Here’s the uncomfortable part. Most people building agent systems right now are thinking like developers, not operators. They optimize for capability and velocity. They want the pipeline to do more, faster, with less friction.
Operators think differently. They assume things will go wrong. They design for detection, not just performance. They ask: when this fails, how will I know? How long will it take me to find the error? How far back do I need to roll back?
The supervision mindset doesn’t make you slower. It makes your pipelines trustworthy enough to actually run in production. And if you’re fanning out to hundreds of agents using the kinds of primitives Cherny is documenting, trustworthiness is the only thing standing between you and a very expensive mistake that took 45 minutes to manufacture itself.
Claude’s computer use feature landing in Claude Code this week, where the agent can now open apps, click through UIs, and test what it built, makes this more urgent. An agent that can interact with real interfaces can do real damage before anyone notices it went sideways.
What I Actually Do Now
I run a dedicated reconciliation agent on every pipeline with more than two hops. It sees only the original task spec and the final output. It doesn’t know what happened in between. Its only job is to score alignment.
I log every inter-agent handoff, not just final outputs. When something goes wrong, I want to find the exact hop where drift was introduced.
I treat any agent output that will be consumed by another agent as untrusted input by default. Same as I’d treat user input in a web application.
None of this is glamorous. But it’s the difference between a demo and a system you can actually rely on.
The agents are getting more capable every month. The orchestration discipline is not keeping pace. That gap is where production incidents live.
Sources
#AIEngineering #AgentOrchestration #MLOps #LLMOps #ClaudeCode #ProductionAI
