The enterprise is a propagation system. Every claim in this piece follows from that one sentence, so it is worth stating before anything else. An enterprise does not primarily exist to record transactions, run processes, or manage relationships, though it does all three. It exists to move operational objects, proposals, shipments, contracts, specifications, customers, from the point they are created to the point a decision gets made about them. Everything an enterprise architects is, at bottom, an attempt to help something move through the organization without losing what it means along the way.
For most of enterprise history, that attempt has failed quietly and constantly. A proposal enters engineering carrying one interpretation and leaves carrying another. A customer exists simultaneously in sales, finance, support, and delivery, each system holding a locally correct and globally incomplete version of who that customer is. Every boundary an object crosses requires someone to reconstruct context that already exists somewhere else in the organization, just not in a form that traveled with the object itself.
Why Propagation
The claim that the enterprise is a propagation system only means something if propagation means something specific, so it is worth being exact about what it is and what it is not.
Propagation is not movement. Workflow moves an object through a sequence of steps, but a workflow can move an object flawlessly while everything the object meant at step one is unrecognizable by step five. Integration moves data between systems, but it typically moves the data stripped of the conditions that gave it meaning in the system it came from, so it arrives intact as a value and dead as an object. Orchestration coordinates when things happen across systems. It governs timing, not meaning. An information system stores an object faithfully in one place, and mistakes that fidelity for the problem being solved, when the actual problem is what happens the moment the object has to leave that place.
Propagation preserves three things as an operational object moves: State, Constraints, and Signals. This is the Propagation Triad, and each element does a specific job. State tells whoever encounters the object where it sits in its own lifecycle, what has already happened to it and what can happen next, so nothing has to be asked and nothing has to be reconstructed. Constraints carry the rules and governing conditions that determine how the object is allowed to move, so enforcement happens structurally, during movement, rather than retrospectively, after something has already gone wrong. Signals are the real-time indicators that let the enterprise observe the object's movement and catch anomalies during execution rather than in next quarter's report.
An object carrying all three arrives at the next boundary already knowing what it is. An object missing any of them arrives silent, and something, a person or now increasingly a model, has to reconstruct the missing piece before a decision can be made.
An object that has only moved has been transported. An object that has propagated has traveled with enough of itself intact that whatever reads it next, a person or a machine, does not have to rebuild what it already knew. This is the specific gap that workflow, integration, and orchestration were never built to close, because none of them were designed to ask whether meaning survived the trip, only whether the object arrived. And it is the actual origin of the intelligence layer, because interpretation is what happens whenever propagation fails and something, a person for most of enterprise history, now increasingly a model, has to rebuild the missing pieces from whatever context clues are left.
Organizations have a comfortable name for that rebuilding. They call it collaboration. Architecturally, it is compensation, the same compensation the Compensation Economy describes: work that exists because the architecture requires it, not because it creates value. Every enterprise already pays for intelligence. It has simply never called it architecture. It appears instead as headcount, as delay, and as the specific person everyone quietly routes around a broken process to reach, the engineer who remembers why a specification changed six years ago, the salesperson who understands what a customer actually meant, the compliance officer who recognizes the applicable regulation on sight, the project manager who can read an unrealistic proposal before the formal review even starts. Organizations call these people institutional knowledge. Architecturally, they are an intelligence layer, implemented in people because no other implementation was ever available.
The Layer That Was Never Built
Enterprise architecture spent the last fifty years formalizing systems of record, systems of process, and systems of engagement, what happened, what happens next, and how the organization feels to the people touching it. None of them addressed propagation directly, and the reason is specific rather than a matter of neglect: until recently, no machine could economically interpret an ambiguous object well enough to preserve its meaning across a boundary. So that work stayed where it had always been. In people.
Large language models reduced the cost of exactly that kind of non-deterministic interpretation, and reducing that cost is the entire significance of the technology for this argument. It is a narrow, specific, economic change, not a philosophical one. Python automated deterministic execution. Large language models reduced the cost of non-deterministic interpretation. Large language models did not create the intelligence layer. They made it economically feasible to build the layer that already existed, informally, expensively, and invisibly, since the beginning of organized enterprise.
What Became Cheap, and What Did Not
It is tempting, watching a rented model interpret a document as well as a ten-year employee, to conclude that intelligence itself has become a commodity. That conclusion does not survive contact with where the intelligence actually was. It never lived in the model. It lived in the enterprise, in the specific accumulated knowledge of its customers, its products, its engineering decisions, its contracts, its failures, its governance, and its operational history. None of that became cheaper when the model did.
What became cheap is interpretation, the mechanical act of reading an ambiguous object and producing a judgment about it. That is a narrow capability, and it is exactly the capability every organization can now rent identically from the same handful of providers. It confers no advantage, because it is no longer scarce anywhere.
Economic advantage has never come from an abundant capability. It comes from whatever stays scarce after the abundant one stops mattering. Cloud computing commoditized infrastructure, and the advantage moved to whoever built faster on top of it. The web commoditized publishing, and the advantage moved to whoever earned attention once anyone could publish. Each generation's cheap capability displaces the advantage rather than eliminating it, and the algorithmic era is no different: large language models commoditized interpretation, and the advantage moved to whoever has enterprise knowledge coherent enough for that now-cheap interpretation to be worth anything. Two organizations can rent the same model and arrive at opposite outcomes, not because one negotiated a better contract, but because one had something coherent to hand it and the other did not.
What the Model Is Actually Doing
The model interprets. It does not decide, and crediting it with deciding hides where the real work is happening. The architecture surrounding the model determines whether its interpretation becomes organizational judgment or organizational confusion. A capable model pointed at a fragmented object interprets that object just as fluently as it interprets a coherent one, and gives no signal that it is interpreting noise rather than substance.
This is why an intelligence layer cannot exceed the coherence of the objects presented to it. If enterprise objects arrive fragmented, the model reconstructs a plausible answer instead of a true one. If enterprise objects arrive having genuinely propagated, carrying State, Constraints, and Signals intact, the model interprets consistently, because there is finally something accurate to interpret. The difference is never in the model. It is always in whether the object it was handed had propagated or merely moved.
This single distinction explains a pattern that shows up identically across proposal evaluation, forecasting, engineering knowledge, and compliance review. In every domain, the mechanism stayed constant while the outcome flipped, depending entirely on whether the object it was given had already propagated coherently through the organization, or had simply been placed in front of it and asked to explain itself. The objective in each successful case was never to build a better conversational interface. It was to build operational objects capable of propagating enough of themselves that interpretation became reliable instead of compensatory. Only once that was true did the interface become genuinely useful, which is worth stating plainly: the interface was never the innovation. The propagation was.
Every organization deploying AI right now is making a structural choice, whether or not it recognizes that it is making one. It can build its intelligence layer on top of the fragmented architecture it already has, in which case the friction that used to be visible, the reconciliation meeting, the spreadsheet built to compare two systems that should already agree, disappears without the fragmentation underneath it disappearing too. Or it can build the intelligence layer on top of an architecture that actually propagates, in which case the layer is not compensating for anything, it is simply reading what was already true. The first organization feels faster immediately and discovers the difference at the worst possible moment, at the scale where two systems disagree and nobody can say which one reflects reality, or under the kind of scrutiny that asks not what the model concluded but what it was allowed to know. The second organization was built on propagated truth instead of inference, and that distinction does not show up in a demonstration. It shows up under load.
The Law
An intelligence layer cannot invent enterprise knowledge. It can only derive judgment from what the enterprise has already propagated to it, at the coherence of the objects it is given, and at the speed those objects are able to move. The intelligence layer inherits the architecture beneath it, for better or for worse, the same way every earlier layer of enterprise software inherited whatever it was built on top of.
This holds even in the cases that look, at first, like an exception. A layer that combines engineering history, legal terms, pricing precedent, customer record, and regulatory constraint, and surfaces a risk no single employee had ever articulated, has not generated new organizational judgment out of nothing. Every piece it combined already existed somewhere in the enterprise. What had never existed was a place where those pieces were assembled together. That is propagation succeeding across a boundary that had never carried anything across it before, not intelligence originating inside the model. The distinction matters because it tells you exactly what to fix when the layer fails: not the model, and not the moment of synthesis, but whatever boundary kept those pieces from ever reaching the same place.
Every claim in this piece is a restatement of that sentence at a different scale.
The Mistake Most Organizations Are Making
Agents execute work. The intelligence layer produces organizational judgment. These are not the same thing, and the current enthusiasm for autonomous agents mostly treats them as interchangeable. Companies are deploying agents at a pace that has less to do with whether their operating environment requires one than with the fact that every competitor in the room is doing the same. This is architecture by imitation, and it produces what imitation always produces: motion without direction. An agent deployed without a coherent intelligence layer beneath it is not exercising organizational judgment. It is improvising inside a gap the architecture left open, quickly and with total confidence, which is more dangerous than the slow uncertainty it replaced.
A second, deeper mistake explains a pattern most executives already recognize without having named it. More effort every quarter, and the same results. That is not a motivation problem. It is the Compensation Ratio, expressed as a lived operating condition rather than a diagnostic exercise. An organization spending a growing share of its effort reconstructing meaning at boundaries the architecture never learned to carry will feel exactly this way, busier every quarter with nothing to show for the increase, regardless of how capable its people are. A correctly built intelligence layer is the first architectural response to this pattern that does not simply ask people to keep working harder inside a gap that was never theirs to close.
The strategic asset in any of this was never the model. It is the architecture that lets enterprise understanding survive the trip from one boundary to the next, and that architecture will outlast whichever model happens to sit inside it this year.
Ten Years Out
If this pattern becomes standard, and every earlier architectural layer eventually did, enterprises a decade from now will be described around four layers instead of three, each with its own governance discipline, its own architects, and its own recognizable failure modes. This will not be evenly good news for everyone inside the organizations that build it. The people whose authority came from being the most reliable interpreters in the room, the reviewer no one could replace, the engineer who was the only one who remembered why, will face the reckoning that every earlier wave of formalized architecture has brought to the informal expertise it replaced. Some will become architects of the new layer. Some will not, and an honest account of this transition says so rather than promising a painless version of it.
The Point
Enterprise architecture spent fifty years optimizing transactions. It never optimized understanding. That gap is closing now, not because artificial intelligence is remarkable in itself, but because it finally made the cost of building the missing layer bearable. Whether this becomes another software category or the next fundamental layer of the enterprise remains to be settled. What is already visible is that organizations across unrelated domains are converging on the same architectural destination without recognizing they are headed to the same place, which is usually the surest sign that a theory has stopped being a theory and started being a description of how things already work.