Algorithms implemented as a sequence of decision steps, each with its own success and failure rate, have an unpleasant property: errors accumulate. If you have a five-step pipeline and each stage solves its task successfully 90% of the time, the overall quality of the result will be 0.9⁵ ≈ 0.59.
In human communication, this is called the telephone game. After just two or three verbal handoffs, the original context is almost gone. Emotional context disappears especially quickly: what matters, what does not, what should be treated as important, and what should not.
AI systems operate on context too, and their failures are often context failures as well – even more literally than in human communication. And these are exactly the kinds of systems we usually use to build pipelines. So the telephone game problem applies to them very directly.
What should we do about it?
We need to change the rules of the game. Agents should not be set up to transmit each other’s errors. They should be set up to correct them. In the modern world, agents do not live in a vacuum. They live in an environment, and that environment is usually file-based. No single agent is the sole source of truth for another. Each of them can verify another agent’s claims through objective interaction with the environment, re-ground itself, and apply judgment.
What follows is that the environment, not other agents, should be treated as the primary source of truth. Other agents are just additional signals: sometimes useful, sometimes strong, but still only signals. The environment is what aggregates many weak signals into something more reliable than any single handoff.
This is why responsibility boundaries matter. We tell agents, in effect: you are responsible for architecture, and if the developer agents write bad code because your architecture was wrong, that is your fault, not the fault of the analyst agent who gave you poor analysis. If the problem is architectural, the system fails because of your judgment.
Once you do this, the agent starts to think differently. It actually tries to share responsibility with us within its own domain. A simple geometric progression of the form
Pᵢ = k · Pᵢ₋₁
starts to turn into something more like
Pᵢ = k · Pᵢ₋₁ + Cᵢ.
Error does not stop accumulating, but it does so much more slowly, because each stage is no longer just passing the previous stage forward. It is also adding some local corrective contribution.
This works for humans too