Models don't just answer questions anymore. They run for hours. Not because inference got slower, but because we learned to put models in loops with tool access, memory, and self-correction, turning a stateless function call into a persistent execution agent. They hold context across sessions, reason through multi-step problems, call tools, write code, and execute entire business processes end-to-end without a human touching an application. When a model can pull customer data from your CRM, check fulfillment status in your ERP, draft a response, and route an exception to a human for approval, it hasn't augmented the application layer. It has become the application layer. And when that same model interacts with a human through conversation, voice, or ambient UI, taking instructions, reporting back, asking for judgment calls, it hasn't enhanced the engagement layer. It has become the interaction layer.
Not everywhere, and not yet for everything. Models can't replace the procurement director who senses a supplier is going under from the way they're negotiating payment terms. That's a read on human behavior sharpened over thirty years, not trained on data. They can't make the call a founder makes when the data is inconclusive and the team is split, where the decision comes down to conviction and the willingness to be wrong. And they can't close the deal that only happens because a sales lead spent three years building trust with a buyer, one honest conversation at a time. The technical reality behind these examples is the same: models fail when the problem requires reasoning over private information they've never seen, in distributions they were never trained on, with consequences they can't simulate. Judgment, instinct, relationships, accountability. These aren't features on a roadmap. They're out-of-distribution problems with no training signal. They're the work that stays human.
But for the vast middle of enterprise work, the workflows and routing and coordination that today requires humans clicking through five applications, the math is changing. The traditional enterprise stack was five neat layers: systems of record at the foundation, integration middleware above, custom business logic in the middle, innovation experiments higher, and engagement layers at the top. For a while, AI slotted in politely. ML models bolted onto existing UIs as recommendation engines. RPA automated workflows humans had already designed. Generative AI showed up as a copilot, still riding shotgun while the human drove. But when the model itself can reason, act, and interact, the layers built to support human navigation of software start to hollow out from the middle.
This is the great compression.
In 2017, Jerry Chen argued the moat was in "Systems of Intelligence" that cross multiple systems of record. He was right about the where. The surprise is the how: the intelligence layer isn't a product category. It's eating the layers around it.
Agent vs Model
Before getting into how, it's worth being precise about a distinction the industry is blurring. An agent is not an AI. It's a program. A loop with memory, tool access, guardrails, and a defined scope of authority. It encodes what the enterprise wants done: what to do, what to access, when to escalate. The model is the expensive function call inside that loop. Stateless intelligence that provides the reasoning, language, and judgment at each step. An agent without a model is a workflow with no brain. A model without an agent is raw intelligence with no mandate. The great compression is driven by models becoming powerful enough to execute, but it's governed by agents that encode the control flow.
Theories of Compression
Not everyone agrees on how this plays out, and it's worth noting that each camp's theory conveniently reinforces its own position. Everyone is talking their book.
The full Nadella thesis. Satya Nadella argued in late 2024 that SaaS applications are fundamentally CRUD databases with business logic in the UI, and that AI will absorb that logic entirely. Applications as a concept cease to exist. Five layers become two: intelligence on top of data. This is the most aggressive framing, and it happens to serve Microsoft perfectly. If the app layer collapses, Copilot and Azure become the center of gravity, and every SaaS vendor becomes a commodity data store riding on Microsoft infrastructure.
The platform absorption play. OpenAI's Frontier, launched this week, positions itself as the "operating system of the enterprise." A semantic layer that connects directly to systems of record, provides shared business context, and orchestrates agents across every function. The middle layers don't just compress; they get replaced by a single external intelligence platform. Naturally, this thesis serves OpenAI's ambition to own the orchestration layer and collect rent on every agent interaction across every enterprise system. A position no single vendor has ever held.
The incumbent expansion. Salesforce's Agentforce and SAP's AI initiatives argue the opposite direction: the system of record itself should become intelligent. Agents live inside CRM and ERP, not on top of them. The middle layers collapse downward into the system of record rather than upward into a new platform. This conveniently preserves the vendor relationship, the data moat, and the per-seat economics that power these companies' revenue, repackaged as "agentic enterprise licenses" instead of user subscriptions. The obvious objection is silos. But the incumbents have a counter: retrieval is getting easier. MCP, connectors, and tool-use protocols mean an agent inside Salesforce can reach into SAP and pull a data point without leaving home. Fair enough. But the real problem was never reading data from another system. It was connecting the data between systems. A supply chain delay logged in SAP needs to update the revenue forecast in Salesforce, which needs to trigger a hiring pause in Workday. That's not three retrievals. That's a chain of dependent writes across three systems of record, each with its own schema, permissions, validation rules, and rollback semantics. A smart agent inside Salesforce can read from SAP all day. It can't write to Workday's headcount plan. It can't enforce consistency across all three when the delay gets resolved. Smart agents in a single system of record don't connect the data between systems. They just make one system more capable in isolation. The incumbents are selling intelligence. The problem requires integration.
While the theorists debate, the compression is already shipping. Ramp built AI agents for controllers that collapsed three layers of enterprise work into one. A single expense used to touch three people and two systems: employee uploads receipt, manager reviews at month end, finance associate opens NetSuite to audit policy, code the expense, and sync the entry. Fourteen minutes of blended labor and over $20 in overhead for a $5 coffee. Ramp's agents handle it autonomously at 99% accuracy, catching 15x more out-of-policy spend than manual review. Humans only see the 10-15% that require real judgment. The engagement layer (employee navigating an app), the workflow layer (approval chain), and the integration layer (receipt-to-accounting sync) all collapsed into a single agent loop. What survived: NetSuite as system of record and humans making exception calls. DoorDash is doing something similar internally, replacing the "search the wiki, ask in Slack, write SQL, file a Jira ticket" workflow with a unified agentic platform using MCP and A2A. Specialized agents handle data exploration, business analysis, and operational questions that used to require context-switching across five tools. Neither company asked which theory of compression was correct. They just compressed.
All three theories share one conviction: the middle of the traditional stack is under extreme pressure. They disagree, self-servingly, on who absorbs it and what replaces it. Ramp and DoorDash suggest a simpler answer: whoever builds the agents first.
Everyone is a builder now. Not developers. Not engineers. Everyone. That's what none of these theories account for. Platform shifts are won by the people who build the applications. In previous eras, that meant developers. iOS won because developers built for it. AWS won because engineers started swiping credit cards before CIOs approved procurement cycles. But this shift is different because everyone is a builder now. A product manager wires together an agent with a prompt, a few tool connections, and an orchestration framework. That's an architectural decision. A process owner in operations reconfigures a workflow from a multi-app approval chain into a single agent with guardrails. That's an architectural decision. A sales lead builds a prospecting agent that pulls from CRM, enrichment APIs, and email in a single loop. That's an architectural decision. None of these people call themselves developers. All of them are choosing the stack. Look at what's already shipping. Anthropic's Cowork puts a general-purpose agent on every knowledge worker's desktop, with Skills for document creation and Plugins that turn it into a specialist for legal review, financial analysis, or marketing ops. These plugins are file-based, open-source, and buildable by anyone. A team lead installs a plugin. A department head commissions one. An individual contributor creates one using Plugin Create without writing code. The agent creation surface has moved from the engineering team to the org chart. Meanwhile, builders across the ecosystem are picking between MCP, LangChain, CrewAI, Semantic Kernel, and dozens of agent frameworks, and those choices, made by thousands of builders across every function, will determine what the enterprise stack looks like in two years. The battle for the orchestration layer will be won by whoever captures this expanding builder ecosystem, not by whoever signs the biggest enterprise contract.
The Emerging Three-Layer Stack
Across these competing views, a new architecture is converging around three layers.
Layer 1: Human–Agent Interface. This replaces the old engagement layer, but it's fundamentally different. Humans no longer navigate applications; they interact with agents through conversation, voice, and ambient interfaces. But the real shift in this layer isn't the modality. It's trust. In the old stack, trust was implicit. A human clicked a button, reviewed the result, and submitted. The human was the control loop. In the new stack, agents act autonomously, sometimes for hours, sometimes across systems, sometimes making decisions with real consequences. Trust has to be engineered into the surface. That means the human needs to see what the agent did, why it did it, and what it's about to do next. It means permissions that scope what an agent can touch. Audit trails that reconstruct every decision. Guardrails that prevent irreversible actions without approval. Kill switches that work. This isn't a governance layer sitting below the interface. It is the interface. The moment you separate trust from interaction, you get agents that act without oversight and humans who lose confidence in the system. The enterprises that get this layer right will move fast. The ones that don't will move fast in the wrong direction.
Layer 2: Intelligence and Orchestration. The three middle layers collapse into one. Models provide the reasoning and contextual awareness. Orchestration handles agent coordination, tool use, protocol-level communication (MCP, A2A), and workflow execution. The underappreciated shift is how agents get created. What used to take months of requirements, development, and QA now takes a prompt, a scope definition, tool connections, and guardrails. Claude Code lets developers build orchestration agents from the terminal. Cowork brings the same agentic execution to non-developers through a desktop interface. Skills handle office formats natively. Plugins bundle everything into installable packages that turn a general-purpose agent into a department specialist: legal reviewer, marketing writer, finance reconciler. Open-source, file-based, buildable by any team without touching an API. Agent creation is collapsing from a software development lifecycle into delegation. But delegation without infrastructure is chaos. Today, there's no version control for prompts. No type system for agent configurations. No compiler that catches a bad guardrail before the agent sends an email to your entire customer base. No staging environment where you test whether two agents conflict before they run in production. The old middleware was ugly but deterministic; the new layer is elegant but probabilistic, and expensive per-inference at scale. Every one of those gaps is a startup opportunity, and the moat in this layer won't be the models or the protocols. It'll be the accumulated operational context: which agents worked, which workflows failed, which human corrections made them better. That knowledge compounds and it's locked to whoever runs the interactions. Despite this, it's the most contested layer in enterprise technology. OpenAI's Frontier, Salesforce's Agentforce, Microsoft's Copilot platform, Anthropic's Cowork and Claude Code. Whoever owns this layer owns the enterprise relationship.
Layer 3: System of Record. It endures. If anything, it becomes more important as the authoritative data foundation that every agent depends on. But its role is shifting. Systems of record are increasingly valued not for their application logic (which is migrating upward into the orchestration layer) but for the data itself. Data access is becoming the new monetization chokepoint, the enterprise equivalent of cloud egress fees. Celonis is suing SAP over data access. Salesforce is raising connector prices. The system of record isn't going anywhere, but the economics around it are changing fast.
The week Anthropic shipped Cowork plugins and OpenAI launched Frontier, $285 billion was wiped from SaaS market caps. Salesforce, ServiceNow, Workday, HubSpot, Thomson Reuters, LegalZoom. The market wasn't reacting to a product demo. It was repricing an architecture. When anyone can install a plugin that does the job of a SaaS product, the per-seat model doesn't erode gradually. It unravels. The selloff may have been premature. The compression is not.
The traditional stack was five layers built for humans navigating applications. The emerging stack is three layers built for models executing work, agents encoding intent, and humans governing the outcome. The middle is collapsing, the builders have changed, and the trust model is being rewritten in real time. The question isn't whether this happens. It's who owns the orchestration layer when it does, and whether the system of record below it survives as a platform or gets commoditized into a dumb datastore with an API and a pricing page. That's where the enterprise relationship lives now. That's where the margin is. That's the battleground.