The approval that approved itself
On a Tuesday morning in January, a procurement manager at a mid-sized logistics company opened her dashboard to review a batch of vendor invoices. Three had already been approved. The amounts were within policy. The vendors were known. The supporting documents matched. An AI agent, integrated across the company's ERP and expense platform, had completed the matching, validated the terms, cross-referenced budget thresholds, and released payment.
She had not delegated this. She had not been asked. The system had not malfunctioned. Everything was, by every measurable standard, correct.
She closed her laptop and went to a meeting. On the walk there, something nagged at her — not that the work had been done wrong, but that she could no longer point to the moment where someone had decided it should be done at all.
This small scene — unremarkable in its surface details — is the quiet center of what public markets began reacting to loudly a few weeks later.
What the sell-off was actually about
In early 2026, a sharp and synchronized decline hit enterprise software stocks. Across multiple sessions, companies that had been valued on the strength of recurring revenue, customer lock-in, and expanding seat counts saw their market capitalizations contract in ways that surprised even seasoned analysts.
The speed was notable. So was the synchrony. This was not a sector rotation triggered by macroeconomic data. It was not a response to missed earnings. Many of the companies in question had reported solid numbers. Their churn rates were stable. Their customers had not left.
And yet the market moved — not against individual companies, but against a category of assumptions. Recurring revenue models had been priced on the expectation that enterprise workflows would continue to live inside discrete applications, that each application would own a durable segment of attention, and that the cost of switching would keep customers captive across renewal cycles.
What changed was not the quality of the software. What changed was the market's confidence that the software would remain the place where work gets done.
Media coverage reached for dramatic framing. Phrases like "the death of SaaS" circulated widely. Commentators drew analogies to past disruptions — the shift from on-premise to cloud, the displacement of licensed software by subscriptions. But these analogies, while emotionally satisfying, obscured the structural nature of what was actually unfolding.
The market was not pricing the collapse of software companies. It was pricing the collapse of a spatial assumption: that work, judgment, and execution would continue to be organized around applications.
Feature competition versus workflow replacement
To understand why this repricing felt so abrupt, it helps to distinguish between two kinds of competitive pressure that enterprise software companies have historically faced.
The first is feature competition. A rival builds a better version of a capability you already offer. They add a smarter search, a cleaner interface, a faster integration. This kind of pressure is familiar. It erodes margins, forces investment, and occasionally reshuffles market share. But it does not threaten the category itself. Customers still need the category. They may switch providers, but they continue to inhabit the same kind of tool.
The second is workflow replacement. This is not a better version of an existing tool. It is the disappearance of the need to use the tool at all — because the work the tool facilitated is now accomplished through a different path entirely.
Markets respond to these two pressures in fundamentally different ways. Feature competition compresses valuations gradually. Workflow replacement compresses them suddenly, because it invalidates the forward assumptions embedded in recurring revenue models. When an analyst builds a discounted cash flow model for a SaaS company, the implicit assumption is that the workflows served by that company will persist in roughly their current form. If those workflows migrate — not to a competitor, but out of the application layer altogether — the model breaks.
This is what happened. Not a loss of customers, but a loss of confidence that the workflows those customers depended on would remain inside the interfaces where they had always lived.
Where execution moved
To see this clearly, consider the anatomy of a typical enterprise workflow before AI agents entered the picture.
A sales team closes a deal. The contract is signed in a contract management platform. The details are entered into a CRM. Revenue recognition is triggered in the finance system. A project is created in the project management tool. Tasks are assigned. Notifications go out. Status meetings are scheduled.
Each of these steps lives inside a different application. Each application charges per seat, per month. The value proposition of each application rests on being the place where a specific type of work is performed and a specific type of record is maintained.
Now introduce an agentic layer. An AI agent, operating across APIs, can execute most of this sequence without a human opening any of the individual applications. The contract is parsed. The CRM is updated. Revenue is recognized. The project is scaffolded. Tasks are assigned based on historical patterns. Status reports are generated and distributed.
The work still happens. The data still flows. But the locus of execution has shifted. It no longer lives inside the application interfaces. It lives in the orchestration layer — in the agent that moves across systems, pulling data from one, pushing actions to another, resolving dependencies without waiting for a human to navigate between tabs.
This is not a theoretical scenario. It is already operational in early-adopter organizations. And its implications extend far beyond efficiency gains.
When execution moves out of applications, the applications do not necessarily disappear. They may persist as systems of record — repositories of structured data that agents read from and write to. But they cease to be systems of work. They are no longer the places where people spend time, make decisions, and exercise judgment. They become infrastructure: essential, but invisible.
The distinction between a system of record and a system of work is not new. But AI agents have made it economically urgent. A system of record can justify a fraction of the price that a system of work commands. The premium in enterprise software has always been attached to attention — to being the environment where humans spend their working hours. When that attention migrates to an orchestration layer, the premium migrates with it.
The layer that is missing
Here is where the conversation, in most accounts, stops. The narrative settles into a tidy arc: SaaS is disrupted, agents are the future, adapt or die.
But this framing misses the most consequential dimension of the shift.
When work lived inside applications, those applications imposed structure on judgment. The approval workflow in a procurement system was not merely a convenience. It was a boundary — a designed constraint that determined who could authorize what, under which conditions, with what visibility. The application did not just facilitate work. It encoded decisions about where judgment was required, who was accountable for exercising it, and what happened when things went wrong.
These boundaries were implicit. They were embedded in role-based access controls, in approval chains, in notification rules, in audit logs. Nobody called them "decision architecture." They were simply how the software worked. But they performed a critical organizational function: they defined where human judgment began and ended.
When execution moves to an agentic layer, these implicit boundaries do not move with it.
The AI agent that approved the invoices on that Tuesday morning was operating within policy. It was technically correct. But the decision boundary — the line that separates autonomous execution from human judgment — had shifted without anyone designing that shift. It had not been discussed in a governance meeting. It had not been reviewed by legal. It had not been mapped against the organization's risk appetite. It had simply happened, as a side effect of a capable system doing what capable systems do: completing the work that was placed in front of it.
This is the missing design layer. Not the technology layer, not the data layer, not the integration layer. The judgment layer. The question of where decisions are made, who is responsible for their consequences, and how those boundaries are designed rather than inherited.
Decision boundaries as organizational architecture
Every organization, whether it knows it or not, operates within a set of decision boundaries. These boundaries define the topology of judgment: which decisions are made by individuals, which are made by teams, which are escalated, which are delegated, and — increasingly — which are executed autonomously by machines.
In the pre-agent era, these boundaries were shaped primarily by software design and organizational hierarchy. The CRM determined what a sales representative could discount. The ERP determined what a finance analyst could approve. The project management platform determined what a team lead could prioritize. The boundaries were rigid, sometimes frustratingly so, but they were legible. You could look at a system and understand, at least in principle, where judgment lived.
AI agents dissolve this legibility. They operate across systems, outside the constraints of any single application's permission model. They can execute sequences of actions that span multiple decision domains — procurement, finance, legal, operations — without pausing at the boundaries that previously separated them.
This is not a flaw in the technology. It is a feature of its architecture. Agents are designed to reduce friction, to complete workflows end-to-end, to eliminate the manual handoffs that slow organizations down. And they do this effectively. But in eliminating friction, they also eliminate the moments of pause — the checkpoints, the reviews, the approvals — that previously served as judgment boundaries.
The result is an organization where execution is faster, more consistent, and more autonomous, but where the structure of judgment has become opaque. No one designed the new boundaries. They emerged as artifacts of what the technology could do, not as expressions of what the organization intended.
This is the design problem that no software vendor is currently solving. It is not a product feature. It is not a platform capability. It is an organizational discipline — the practice of deliberately designing where judgment happens, who owns it, and how it evolves as autonomous execution expands.
What legacy SaaS economics actually depended on
Seen through this lens, the market repricing of enterprise software stocks takes on a different character.
Legacy SaaS economics were not merely built on recurring revenue, customer stickiness, and expanding seat counts. They were built on a deeper, unexamined assumption: that the applications themselves would continue to serve as the containers for organizational judgment.
Every seat license was, implicitly, a license for a human to exercise judgment within a bounded environment. The value of the software was not just functional — it was structural. It provided the scaffolding within which decisions were made, tracked, and attributed.
When agents relocate execution outside those environments, the structural value does not transfer automatically to the agent layer. It dissipates. And what remains is a gap — an undesigned space where judgment occurs without clear ownership, where responsibility is distributed without clear boundaries, and where accountability defaults to whoever happens to be nearest when something goes wrong.
SaaS is not dying. The applications will persist, many of them for decades. But the economic model that sustained them — the model that priced attention, judgment, and workflow residency as a single bundled value — is decomposing into its component parts. Data persistence will command one price. Execution facilitation will command another. And judgment architecture — the deliberate design of decision boundaries — will command a third, though few organizations have yet recognized it as a distinct category of value.
What comes next is not a platform
The instinct, in moments of structural transition, is to look for the next platform. The next category of software that will consolidate the new landscape and establish the next generation of recurring revenue models.
But the shift underway does not resolve into a platform. It resolves into a discipline.
The organizations that will navigate this transition most effectively are not the ones that adopt the most sophisticated AI agents. They are the ones that develop the capacity to design, monitor, and evolve their decision boundaries as execution becomes increasingly autonomous.
This is not a technology challenge. It is an organizational design challenge. It requires understanding judgment not as an individual cognitive act, but as a structural property of the organization — something that can be mapped, allocated, and governed.
The future competitive advantage does not belong to the company that owns the best interface, or the most comprehensive data, or the most capable agent. It belongs to the company that knows, with precision and intention, where judgment is learned, where it is exercised, and where it is owned.
In the age of autonomous execution, the scarcest resource is not intelligence. It is the deliberate design of where intelligence is permitted to act — and where it is not.
That design is not a feature. It is not a product. It is the architecture of organizational responsibility itself. And it is, today, almost entirely unbuilt.