The Software Collapse & The New Stack
Something structural is happening to software. Not a product cycle. Not a platform shift in the usual sense. A deeper restructuring of who sits between data and action, and what that means for every company that has built on the assumption that the answer was a human.
This series spent ten issues tracing that restructuring from multiple angles: the disruption frame, the strategic responses, and the infrastructure wars underneath. What follows is the synthesis — the single argument that all ten pieces were building toward.
The Central Disruption
AI agents don’t consume software the way humans do. They don’t need GUIs. They don’t need dashboards, menus, or onboarding flows. They need APIs, permissions, and outcomes. Which means the entire UX layer that SaaS companies spent three decades investing in becomes overhead.
This is not a marginal change. The human-in-the-loop was not incidental to SaaS design. It was the core assumption. Every workflow, every notification, every approval screen, every reporting module was built for a person making a decision. Remove that person, and you don’t just simplify the software — you remove the reason most of it was built in the first place.
The first question the series asked was deceptively simple: if the human is no longer the user, what is software for?
The answer is: software is no longer a system of record. It is becoming a system of action. And that distinction — between recording human decisions and executing them autonomously — is the fault line the entire industry is now navigating.
Where the Value Is Moving
Not every SaaS company loses equally in this transition. Value doesn’t disappear when a technology shifts — it migrates to whoever controls the new bottleneck.
In the SaaS era, that bottleneck was workflow:
Salesforce-owned sales
Workday-owned HR
ServiceNow owns IT operations
The moat was the workflow, and the workflow was designed around the human doing the work.
In the agentic era, the bottleneck shifts. Agents don’t need workflow software — they need structured, machine-readable representations of enterprise knowledge. The semantic layer. The thing that tells an agent not just what happened, but what it means, what it connects to, and what to do next.
Value is migrating from the tools that managed human workflows to the infrastructure that makes enterprise knowledge legible to machines. This isn’t happening because a better workflow tool arrived. It’s happening because the workflow paradigm itself is being displaced.
The UX Inversion
The most visible symptom of this shift is what happens to the interface layer.
For decades, UX was a genuine competitive differentiator. The company with the better interface won the enterprise deal, held the renewal, and commanded the premium. Good design was a moat.
That logic is inverting. If agents are the primary consumers of software:
Interface quality becomes irrelevant to the primary use case
API quality becomes the new differentiator — the cleanliness of the programmatic surface, the reliability of the schema, the richness of the data model
Companies that competed on design are now competing on a dimension they never prioritized, against infrastructure vendors who always did
This isn’t a design story. It’s a resource allocation story. The R&D investment, the hiring profile, and the product roadmap priorities that made SaaS companies successful are now misaligned with what the market is selecting for. The inversion is already underway. Most companies haven’t fully recognized it yet.
How Incumbents Are Responding
The most instructive case study in the series was Salesforce — the company that built the SaaS era’s definitive business model and is now selling agents that replace the workflows its own platform was designed to support.
This is not a contradiction. It is the only rational strategy available to an incumbent at scale facing architectural displacement. The answer — Agentforce, Einstein, the entire agentic product line — is a bet that customer lock-in survives product disruption. That the relationships, the data, and the depth of implementation accumulated over decades are more durable than the particular delivery mechanism.
Call it agentic cannibalization. The incumbent eats its own revenue before someone else does, repackaging value delivery rather than defending the old form. It works only where the underlying relationship is real — where there is genuine data gravity, genuine switching cost, genuine enterprise trust that transcends the product.
The distinction matters because it determines the entire strategic calculus:
Moats built on workflow habit → fragile in the agentic transition
Moats built on data accumulation, institutional knowledge, deep integration → have a path through
The New Architecture
The old stack was horizontal — software organized by business function: CRM, HRIS, ERP, ITSM. Each tool owned a slice of the enterprise workflow. Integration was the tax you paid to connect them.
The new stack is vertical. Built around outcomes rather than functions. Its layers:
Orchestration — manages agent tasks, routes between tools, maintains context, handles authorization
Memory and context — gives agents access to enterprise knowledge across sessions
Data and infrastructure — where the actual intelligence lives
The most contested real estate is the orchestration layer. Whoever controls orchestration controls which tools get called, in what sequence, with what context, at what cost. It is the new enterprise relationship — not the CRM, not the ERP, but the layer above all of them that decides how they get used.
When Agents Transact
The agentic shift isn’t only a SaaS story. When agents act on behalf of humans, they also spend on behalf of humans — and that re-plumbs the entire enterprise payments layer.
Trust, authorization, micro-billing, real-time settlement become infrastructure problems, not product features. The implications run deep:
Who holds spending authority when the spender is a machine?
How do card networks, treasury systems, and ERP vendors adapt when the transaction initiator isn’t human?
What does audit and compliance look like when the approval chain is automated end-to-end?
The Infrastructure Wars
The deepest layer of the series — and arguably the most consequential — was the competition playing out at the data infrastructure level.
Snowflake and Databricks are competing for the same prize: becoming the intelligence substrate underneath the enterprise AI stack. The company that wins doesn’t just win a market category. It determines where enterprise AI gets anchored — in the model layer or in the data layer.
The structural variable is data gravity. Compute moves toward data, not the reverse. Enterprises have spent years accumulating data in these platforms. That accumulation creates switching costs that survive even significant product disruption — which gives both companies a structural path through the agentic transition that workflow-SaaS companies lack.
MongoDB represents a different version of the same question:
Built for schema flexibility, it now faces a world in which AI can generate schemas dynamically and write the code to query them. The developer-first paradigm was built on the assumption that developers are the bottleneck. What happens when they aren’t?
The Three Positions
Every enterprise software company is currently making one of three structural bets — most without fully recognizing they are making it.
1. Cannibalize yourself Sell the agents that replace your own workflows before a competitor does. The bet: customer relationships outlast product disruption. Works only where lock-in is real. (Salesforce is the clearest example.)
2. Become the substrate Don’t compete with the agent layer — become what agents run on. Own the data, the query infrastructure, the semantic memory. The bet: data gravity survives the AI transition. (Snowflake, Databricks — from different angles.)
3. Commoditize Remain the technical plumbing that agents use invisibly. Survive, but without pricing power. Margin compression without displacement. This is the default outcome for companies that neither cannibalize themselves nor build genuine data gravity.
The uncomfortable truth: most enterprise software companies are drifting toward position three while believing they’re executing position one or two.
What Comes Next
The series has mapped the technology, the competitive dynamics, and the strategic responses. What it hasn’t fully explored is where the transition is actually bottlenecked — the human dimension.
Three open questions that the next arc will address:
The enterprise buyer’s psychology. Migrations are slower than the disruption warrants. Organizational inertia is not irrationality — it’s the rational response to switching costs, risk exposure, and a credibility gap with AI vendors who have overpromised before. That inertia is the arbitrage window AI-native vendors are currently exploiting. It is closing faster than most incumbents realize.
The regulatory constraint. GDPR, SOX, HIPAA, and financial services regulation all assume a human is accountable for decisions. When agents transact and execute autonomously, accountability becomes a legal question with no existing framework. The companies that help define those frameworks will have a structural advantage in the industries where regulation is the real deployment constraint.
The talent re-allocation. If the UX layer commoditizes, UX engineering follows. If agents write code, developer productivity restructures. If workflow software is displaced, implementation consulting contracts. The labor market consequences of the software transition are as structural as the product consequences — and they will reshape enterprise software spending in ways most competitive analysis hasn’t captured yet.
The Compression
The software transition isn’t a product cycle.
It’s a restructuring of who — or what — sits between data and action. The SaaS era was built on the assumption that the answer was a human. Software’s job was to inform that human and record what they decided. The agentic era removes that assumption. Software now acts. And everything built on the premise that it wouldn’t is being renegotiated.
Every piece in this series traced the same line: from data to action, and what falls away in between.
Recap: In This Issue!
omething deeper than a product cycle is happening to software.
The core restructuring is this:
the layer sitting between data and action is changing.
In the SaaS era, that layer was the human user.
Software informed the human, guided the workflow, and recorded the decision.
In the agentic era, software increasingly acts directly.
That shift changes what software is for, where value sits, and which companies retain pricing power.
The Central Disruption
Human-Centric SaaS Logic
SaaS products were built around a human operator.
That assumption shaped everything:
dashboards
menus
approval flows
notifications
reporting layers
onboarding systems
These were not optional interface choices.
They were the architecture of software designed for people making decisions.
Agentic Logic
AI agents do not consume software the same way.
They do not need:
GUIs
dashboards
onboarding flows
navigation
They need:
APIs
permissions
context
execution paths
outcomes
This means much of the UX layer becomes structural overhead.
Once the human is no longer the primary user, much of the software built to support human decision-making loses its reason for existing.
From System of Record to System of Action
The Old Role of Software
Traditional enterprise software primarily recorded human decisions.
Examples:
a salesperson updates CRM records
an HR manager approves a workflow
an IT operator resolves a ticket
a finance team processes an approval chain
The software stored and displayed the state of the work.
The New Role of Software
In the agentic model, software increasingly executes the work.
The system is no longer just recording actions after the fact.
It is becoming a system of action.
This is the defining fault line in enterprise software.
The key distinction is no longer:
what workflow does this product manage?
It becomes:
what outcome can this system execute autonomously?
Where Value Is Moving
The SaaS Bottleneck
In the SaaS era, value accumulated around workflow ownership.
Examples:
Salesforce owned sales workflows
Workday owned HR workflows
ServiceNow owned IT workflows
The moat was the human workflow itself.
The Agentic Bottleneck
In the agentic era, value moves away from workflow interfaces and toward the infrastructure that makes enterprise knowledge usable by machines.
Agents need:
structured enterprise context
semantic relationships
machine-readable data
persistent memory
action logic
This shifts value from workflow software to the semantic and infrastructure layers that make enterprise knowledge legible to machines.
The bottleneck is no longer workflow habit.
It is machine-readable context.
The UX Inversion
Why UX Mattered Before
For decades, interface quality was a real competitive advantage.
Better UX meant:
easier adoption
stronger usage habits
higher retention
stronger enterprise differentiation
Good design functioned as a moat.
Why UX Matters Less Now
If agents become the primary consumers of software, interface quality matters less to the primary use case.
The differentiator shifts toward:
API quality
schema quality
semantic richness
programmatic reliability
permission design
Companies that invested heavily in user-facing UX now compete on a dimension many infrastructure vendors were already built for.
This is not primarily a design problem.
It is a resource allocation problem.
The capabilities that made SaaS companies strong are no longer the capabilities most selected for by the market.
How Incumbents Are Responding
The Logic of Self-Cannibalization
The most rational incumbent response is to replace your own workflow product before someone else does.
This is what large incumbents are attempting when they introduce agentic product lines that partially undermine their existing seat-based logic.
This is not contradiction.
It is strategic self-preservation.
When It Works
Self-cannibalization only works when the incumbent has a moat beneath the workflow layer.
That moat can include:
accumulated enterprise data
implementation depth
institutional trust
deep integration
durable switching costs
If the relationship is real, the delivery model can change while the account remains defensible.
When It Fails
If the moat was mainly:
UI habit
workflow familiarity
feature breadth without deep data gravity
then the transition becomes much more dangerous.
The distinction is simple:
workflow habit is fragile
data gravity is durable
The New Software Architecture
The Old Stack
The SaaS stack was organized horizontally by business function.
Examples:
CRM
ERP
HRIS
ITSM
Each product owned a functional slice of the enterprise.
Integration stitched them together.
The New Stack
The agentic stack is increasingly vertical, built around outcomes rather than functions.
Its core layers are:
Orchestration
Routes tasks across systems, manages permissions, maintains context, and decides how tools are used.
Memory and Context
Stores enterprise knowledge across sessions and interactions.
Data and Infrastructure
Holds the actual intelligence substrate on which agentic systems run.
Why Orchestration Matters Most
The orchestration layer is the most contested part of the stack.
Whoever controls orchestration controls:
which systems get called
in what order
with what context
at what cost
under what permissions
That makes orchestration the new enterprise relationship layer.
It sits above CRM, ERP, and workflow apps and determines how they are actually used.
When Agents Start Transacting
The Shift Beyond SaaS
The transition is not limited to productivity software.
When agents act on behalf of humans, they also begin to spend on behalf of humans.
That pushes the same structural shift into payments and finance infrastructure.
The New Questions
This creates new infrastructure problems:
who grants spending authority to a machine?
how is authorization enforced in real time?
how does audit work when approvals are automated?
how do compliance systems adapt when humans are no longer directly initiating each transaction?
Payments, treasury, ERP, and compliance systems all get pulled into the agentic transition.
The Infrastructure Wars
Why Infrastructure Gains Power
The deepest competitive battle is at the data infrastructure layer.
This is where the agentic stack anchors because agents need to operate where enterprise data already lives.
The key structural force is data gravity.
Compute moves toward data.
Data does not move easily toward compute.
That gives infrastructure players with accumulated enterprise data a structural advantage.
What This Means Strategically
Platforms that already hold large volumes of enterprise data are better positioned for the transition because their switching costs persist even if the interface layer gets disrupted.
They have a credible path to becoming the substrate agents run on.
That is a stronger position than workflow SaaS vendors whose value depended mainly on human navigation.
The Developer Paradigm Under Pressure
This same logic reaches developer infrastructure.
If AI can generate schemas, write queries, and produce code dynamically, then software built around the assumption that developers are the bottleneck faces the same structural challenge.
The question becomes:
what happens when the person previously required to mediate the system is no longer the limiting factor?
The Three Strategic Positions
Every enterprise software company is drifting toward one of three structural positions.
Cannibalize Yourself
Sell the agent that replaces your own workflow before a competitor does.
This works only if the customer relationship is durable enough to survive product-form disruption.
Become the Substrate
Stop competing at the workflow layer.
Instead, become the infrastructure agents depend on:
data layer
query layer
semantic layer
memory layer
This is the strongest long-term position if genuine data gravity exists.
Become Invisible Plumbing
Remain a technical dependency used by agents but without owning the strategic relationship.
This allows survival, but usually with lower pricing power and margin pressure.
This is the default outcome for many companies that believe they are moving up-stack but are not actually creating either orchestration control or data gravity.
What Comes Next
The Buyer Constraint
Enterprise adoption does not move as quickly as the technology disruption suggests.
This is not irrational conservatism.
It reflects:
switching costs
operational risk
prior overpromising by AI vendors
organizational inertia
This creates a temporary arbitrage window for AI-native challengers, but that window will narrow.
The Regulatory Constraint
Current regulatory systems assume a human remains accountable for key decisions.
That assumption becomes unstable when agents:
approve
execute
transact
communicate autonomously
The firms that help define legal and compliance structures for autonomous execution will gain structural advantage in regulated sectors.
The Talent Constraint
If the interface layer commoditizes, then labor attached to that layer also gets repriced.
That affects:
UX engineering
implementation consulting
workflow configuration roles
parts of developer labor
The software transition is therefore also a labor-market transition.
That will reshape spending patterns across enterprise software categories.
Strategic Compression
This is not just a software cycle.
It is a restructuring of what sits between data and action.
In the SaaS era, the answer was the human.
Software’s role was to inform that human and capture the decision.
In the agentic era, software increasingly executes the decision itself.
That means every company built on the assumption that humans would remain the operating layer is now being renegotiated.
The winning companies will not be those with the best dashboards.
They will be the ones that control:
machine-readable context
orchestration
semantic memory
trusted execution layers
The shift is not coming.
It is already underway.
With massive ♥️ Gennaro Cuofano, The Business Engineer