Your AI strategy is a game of telephone

Every failed AI initiative has the same autopsy. The strategy was sound. The deck was approved. The team was capable. And the thing that shipped, eighteen months later, was a shadow of what everyone agreed to build. The postmortem blames execution, or scope, or the model. It is usually none of those. It is translation.

Every kid has played telephone. A sentence goes in at one end of the line, gets whispered from ear to ear, and comes out the other end as nonsense. The fun of the game is that nobody lied and nobody meant to break it. The message degraded because passing a message degrades it.

Organizations play the same game with better stationery. Strategy hands a deck to product. Product hands requirements to design. Design hands specs to engineering. Engineering hands code to QA and compliance. Each handoff produces a new artifact, written for a new audience, in a new format. And each artifact is a compression of the one before it.

Engineers call this kind of compression lossy: the artifact gets smaller because detail gets thrown away, permanently. And here the corporate game turns out to be crueler than the playground one. Telephone garbles at random, which is why the results are funny. Handoffs lose selectively, which is why the results are expensive. What survives is what fits the format: features, dates, metrics, bullet points. What dies is the reasoning. The tradeoff that was argued for an hour survives as a checkbox. The boundary condition that motivated the whole initiative survives as a footnote nobody reads. Intent does not fit in a spreadsheet cell, so intent is what the game drops. Every time, the same casualty.

Classic software could absorb this tax. The layers were separable. A payments API could be specced precisely enough that the implementing engineer needed no access to the strategic reasoning; the interface was the contract, and the contract could be written down completely.

Agentic systems are different, and the difference is structural.

Everything touches everything

Consider one sentence from a strategy deck: “The agent escalates sensitive cases to a human.”

In an agentic system, that sentence is simultaneously a policy decision (what counts as sensitive, and who decided), a knowledge decision (what the agent must understand to recognize sensitivity), a context decision (what signals it can see when the moment arrives), a UX decision (how the handoff feels to a person mid-conversation), and a code decision (the deterministic trigger that fires regardless of what the model thinks).

Those are not five tasks for five teams. They are one design with five surfaces. Pass them down the line and each team resolves its ambiguity locally. By the fourth handoff, “escalates sensitive cases” has become a keyword list, because a keyword list is what fits in a ticket. The compliance nuance that justified the feature died three artifacts back, and nobody was present at both its birth and its burial.

This is why agent initiatives fail in a way that surprises experienced software organizations. The same chain of handoffs that reliably shipped their last decade of products quietly destroys the thing that matters most in this one: the connective reasoning between what the system should do and what it must never do.

What the tax costs

The translation tax compounds in both directions. Downstream, constraints arrive at the keyboard as vague bullets, so engineers guess, and the guesses are invisible until an audit or an incident surfaces them. Upstream, the people who set strategy never feel the texture of what shipped, so the next deck is written about an imaginary product.

The standard remedies make it worse. More documentation adds more artifacts to compress. More meetings add more retellings. More process adds more handoffs. You cannot fix a lossy channel by sending more through it.

The integrated alternative

The fix is fewer translations, not better ones.

The interesting agent work right now is happening in small, integrated teams where the person who argued the policy tradeoff is in the room, or in the repository, when it becomes a trigger condition. Sometimes it is happening in one mind: the same person holding the regulatory reasoning, the knowledge architecture, and the code. Not because small teams are virtuous, but because information that never gets handed off never gets compressed.

This is an information-loss argument, not a headcount argument. A large organization can lower the tax the same way: put strategy and implementation inside one mental model, give the people writing the constraints access to the people encoding them, and measure the distance between the deck and the deploy as if it were a defect rate. Because it is one.

When an engagement spans the full arc, the original thinking ships intact. That sentence has been on our site since the beginning. This essay is the reasoning behind it.