In The Great Compression, we documented how six model providers deployed $200B+ to absorb every middleware function that stood between foundation models and enterprise workloads. In The Great Compression Was Never Just About Middleware, we showed the same logic executing at the services layer — absorbing the implementation relationship that consulting firms had claimed as their moat. The compression has now arrived at a third destination. Not a function. Not a relationship. The execution substrate itself.
The DeepLearning.AI newsletter described it as OpenAI and Amazon building “a stateful runtime environment — a forthcoming computing infrastructure designed for AI agents.” Most readers filed it under cloud partnerships and competitive positioning between OpenAI, Microsoft, and Amazon. Those readers are missing the structural event. This is the Great Compression executing one level deeper than anything we have previously documented — inside the layer that governs not what enterprise agents do, but whether they can continue doing it.
The announcement introduces joint infrastructure for managing agents’ working states: memories, tool connections, user permissions, and resumption logic. It will run on Amazon Bedrock AgentCore — the same platform whose emergence we documented in The Great Compression as AWS’s contribution to the provider-native harness layer. What has changed is not the platform. It is what the platform is now absorbing.
The Amazon investment commitment contractually contingent on the cloud partnership remaining intact — per SEC filings reviewed by GeekWire. Not a financial figure in isolation. A governance instrument. The compression has fused financial stake, infrastructure relationship, and execution substrate into a single contractual object. Enterprises building on this runtime are not simply adopting infrastructure. They are entering a financial dependency structure.
Understanding what this means requires distinguishing between what the prior compressions absorbed and what this one does. Post 1 and Post 2 documented the absorption of discrete functions and discrete relationships — each replaceable, at cost, with friction. The state layer is different in kind.
What the State Layer Actually Is
The agent harness layer — orchestration, evaluation, memory, observability, tool integration — is the infrastructure that enables agents to act. The state layer is different: it is the infrastructure that enables agents to continue. When an agent executes a complex multi-step workflow and is interrupted — by a human approval gate, a tool failure, a permission check, or a timeout — something must preserve what the agent knew, what tools it had connected, what permissions it held, and where in the workflow it stopped. That something is the state layer.
OpenAI’s framing is explicit about what the stateful runtime manages: “agents’ working states including memories, tool connections, and user permissions.” The company argues that stateless APIs — the conventional mechanism through which developers access foundation models — are insufficient for production agents, which “depend on outputs from multiple tools, require human approvals, and must resume if they’re interrupted.” This is architecturally correct. Stateless APIs require every piece of context to be passed with every request. For simple conversational interactions, that is manageable. For agents executing multi-day workflows across dozens of tool calls with human intervention points, it is not.
The prior compressions absorbed what agents do. This one absorbs whether they can continue. That is a different category of dependency — and it has no natural substitute.
— Tom M. Gomez, Luminity DigitalThe architectural consequence is precise. An enterprise that migrates from one orchestration framework to another carries migration complexity — but its agents continue operating. An enterprise that migrates from a provider-native state layer carries something structurally different: the simultaneous loss of every agent’s working state, every established tool connection, every permission context accumulated through weeks of workflow execution, and every in-progress multi-step task. The execution continuity lives in the provider’s infrastructure. Moving the agent means abandoning its memory of everything it was doing.
This is the distinction that enterprise architects must hold clearly. The Harness Imperative series documented why architectural control over the harness layer is the enterprise’s primary governance lever — why the harness is the moat. The Alignment Gate went further: the harness layer is the only place to govern recursive AI. Both arguments assume the harness layer is something you own. The state layer capture changes that assumption. Losing governance of the harness is a serious structural risk. Losing governance of the state layer is the condition under which you cannot recover what you built — because the substrate that would sustain any recovery is no longer yours.
The Definitional Engineering Move
The mechanism through which the OpenAI–AWS stateful runtime was constructed reveals a new instrument in the compression toolkit — one that Posts 1 and 2 did not need to address because it had not yet been deployed at this scale.
The prior compression mechanisms were three: acquisition (OpenAI’s eight harness-layer purchases, Meta’s Manus and Scale AI transactions), open-source protocol control (Anthropic’s MCP at 97 million monthly SDK downloads, Google’s ADK at seven million), and managed runtime integration (Microsoft Agent Framework, AWS Bedrock AgentCore, Google Vertex AI Agent Engine). Each absorbed harness functions through a distinct structural move. The fourth mechanism is definitional engineering: redefining what a function is in order to capture territory that existing contracts prohibit.
The relevant contract is the 2019 Microsoft–OpenAI partnership. Its terms grant Microsoft the exclusive right to host OpenAI’s stateless APIs. A stateless API — one in which each request is independent and the provider retains no memory of prior exchanges — has a straightforward definition. Microsoft’s exclusivity was written around that category. The OpenAI–Amazon stateful runtime was architected precisely to fall outside it. Azure will continue to host stateless API calls arising from the Amazon collaboration. AWS hosts the stateful runtime. The technical distinction is real. The legal convenience is not coincidental.
The stateless/stateful boundary is not a natural technical category emerging from first principles. It is a competitive instrument drawn at a line that happens to coincide exactly with Microsoft’s contractual exclusivity. The compression has learned to use infrastructure categorization as a forward-positioning tool — defining new infrastructure classes before governance frameworks, enterprise contracts, and regulatory categories have mapped them.
What makes this significant beyond the OpenAI–Microsoft–Amazon triangle is what it signals about how the compression intends to proceed. When acquisition targets are exhausted and protocol standards are established, the next instrument is category redefinition — drawing new infrastructure boundaries in terrain that existing frameworks have not yet reached. Enterprises operating on provider-defined infrastructure categories are operating in terrain the provider drew. The definitions will continue to move.
Functions and Relationships Absorbed
Middleware functions absorbed through acquisition, open-source protocol control, and managed runtime integration. Implementation relationships absorbed through PE JV structures and forward-deployed engineering models.
Each compression targeted a discrete object. Each could, in principle, be replaced — at cost, with friction, but without disrupting the operational continuity of agents already in production.
Documented in Posts 1 & 2Execution Continuity Absorbed
Working memory, tool session state, user permission contexts, and workflow resumption logic absorbed into a provider-native runtime — jointly built and jointly owned by a model provider and a hyperscale cloud provider.
The dependency is not interchangeable. Migrating from this runtime means abandoning the operational state of every agent in production. The compression has reached the substrate beneath substitution.
AcceleratingThe Investment-Infrastructure Coupling
The financial architecture of the OpenAI–Amazon deal introduces a governance risk category that enterprise frameworks have not yet named. Understanding it requires treating the deal not as an investment with a cloud partnership attached, but as a single contractual object with three inseparable components: equity stake, infrastructure access, and execution substrate.
Amazon’s confirmed $15 billion investment carries an additional $35 billion commitment — contingent, per SEC filings reviewed by GeekWire, on the cloud partnership remaining intact. If the partnership terminates, the remaining commitment terminates with it. The investment is not independent of the infrastructure relationship.
The financial stake and the execution substrate are the same instrument, priced as equity.
The Contractual Substrate Risk
When a model provider controls both the execution substrate and the investment relationship, the portability question changes character. An enterprise exiting a vendor’s orchestration framework faces migration cost. An enterprise exiting a provider-native stateful runtime faces something structurally different: the simultaneous loss of every agent’s working state, every tool connection, every permission context, and every in-progress workflow — not as a migration challenge, but as an instantaneous operational discontinuity.
The Amazon deal makes this dependency explicit in financial terms. The $35B contingent commitment is tied to the cloud partnership. Enterprises building production agents on this runtime are not simply adopting infrastructure. They are entering a financial dependency structure in which their execution substrate is collateral in someone else’s investment thesis.
NIST’s AI Risk Management Framework addresses continuous operational risk management across the full AI lifecycle. It does not address the scenario in which the infrastructure provider’s investment commitment is the mechanism of lock-in. That gap is not hypothetical. It is the current architecture of the largest AI infrastructure deal in history.
For enterprise architects, the implications of this coupling are practical and immediate. The conventional portability audit — assessing migration cost for orchestration frameworks, evaluation tooling, and vector storage — does not reach what the state layer introduces. The question is no longer “how much would it cost to migrate?” It is “what operational state would we lose that cannot be reconstructed at all?”
The answer, for enterprises that have allowed agent execution continuity to live in a provider-native runtime, is everything their agents were doing at the moment of migration — not historical data, not model fine-tunes, not configuration. The working memory of every active agent, the permission contexts accumulated through months of enterprise workflow execution, the tool connections established across dozens of integrations. That state is not portable by design. It is the product.
The Road Ahead
The state layer capture is not the endpoint of the compression. It is the third documented move in what is proving to be a systematic advance toward full-stack control — from model to orchestration to implementation to execution substrate. The architecture of dependency is being assembled with a deliberateness that should trouble enterprise architects more than it currently does.
There are more casualties ahead on this route. Infrastructure companies whose value propositions assumed independence from provider-controlled state management — whose moats were built on the premise that the execution layer would remain open and neutral — are in a structurally more difficult position than their current valuations reflect. The compression does not announce its next targets. It absorbs them, and the market learns about it afterward.
The governance problem that will define the next phase of enterprise AI adoption has not yet arrived in full force. Its conditions are being assembled now. Every enterprise agent running on a provider-native stateful runtime, with a provider-native harness, evaluated by provider-native tooling, deployed by a provider-affiliated forward-deployed team, represents an enterprise that has concentrated not just technology dependencies but operational continuity — its ability to function as an AI-enabled organization — in a single provider relationship. When that relationship changes, as all provider relationships eventually do, the question will not be how to migrate. It will be whether anything operational survives the transition.
The compression was never just about middleware. It was never just about the partner layer. It is about who controls the full stack from model to outcome — including the substrate that determines whether the outcome is even reachable.
That substrate is no longer neutral. And the road has considerably more to cover.
