Your AI strategy is a game of telephone

Every failed AI initiative has the same autopsy. The strategy was sound, the deck was approved, and the team was capable. Yet the thing that shipped eighteen months later was a shadow of what everyone agreed to build. The postmortem blames execution, scope, or the model. Usually the real cause 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 for good. 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, and 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 becomes a footnote nobody reads. Intent does not fit in a spreadsheet cell, so intent is what the game drops, every time.

Classic software could absorb this tax because the layers were separable. A payments API could be specified precisely enough that the engineer building it needed none of 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 five decisions at once. It is a policy decision: what counts as sensitive, and who decided. It is a knowledge decision: what the agent must understand to recognize sensitivity. It is a context decision: what signals the agent can see when the moment arrives. It is a UX decision: how the handoff feels to a person mid-conversation. And it is a code decision: the deterministic trigger that fires regardless of what the model thinks.

Those five decisions are one design with five surfaces, and handing them to five teams splits it apart. 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. Nobody was present at both its birth and its burial.

This is why agent initiatives surprise experienced software organizations. The chain of handoffs that reliably shipped their last decade of products now destroys the thing that matters most. That thing is 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 reach the keyboard as vague bullets, so engineers guess. Those guesses stay 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 most interesting agent work right now happens in small, integrated teams. The person who argued the policy tradeoff is in the room, or in the repository, when it becomes a trigger condition. Sometimes it happens in one mind that holds the regulatory reasoning, the knowledge architecture, and the code. Small teams are not virtuous in themselves. Information that never gets handed off simply never gets compressed.

Large organizations can lower the tax too. Put strategy and implementation inside one mental model. Give the people writing the constraints direct access to the people encoding them. Then measure the distance between the deck and the deploy as a defect rate, because that is what it is.