Microsoft CEO Satya Nadella said something on the BG2 podcast that stuck with me; it clarified a shift I'd been circling for a while. In a conversation with Bill Gurley about whether AI-first startups could make legacy software obsolete, he said:
As the years passed, I kept coming back to that idea and its implications. Every technology leader can sense the shift, but to see where it goes, you have to understand what software was solving for in the first place, and why that problem is going away.
Key Concepts
- Enterprise applications were built to translate human intent into machine instructions, and agentic AI eliminates that translation layer.
- Most organizations are still layering AI on top of existing architectures; the real gains come from rebuilding around it.
- AI governance, particularly identity governance and administration and segregation of duties, breaks when logic moves to runtime.
- The organizations that restructure work around outcomes instead of tools will operate at a different cost level entirely.
Enterprise software was built as a workaround
Software was always a workaround.
A line of code is a human anticipating a scenario and defining the answer in advance. Every application ever built was an attempt to translate human intent into instructions precise enough that a machine lacking judgment could execute correctly.
When a system produced an unexpected result, we called it a bug, but it was actually executing exactly as designed. The failure showed up when the data changed, and the system kept executing against conditions that no longer held. The real flaw was the assumption that we could anticipate everything in advance.
That assumption shaped fifty years of technology, from architecture and developer roles to IT departments and procurement. When it lifts, everything built around it is up for redesign.
The factory floor problem with enterprise AI
The history of industrial electricity is the clearest parallel to where we are. Andrej Safundzic, CEO of Lumos, made this point not too long ago.
When electricity arrived in the 1890s, factory owners kept their existing designs. They swapped the steam engine for an electric motor, but everything around it stayed the same. The shafts, belts, and multi-story layouts were still built for the old power model. Productivity barely moved for decades.
It took years before anyone questioned the layout itself. When Albert Kahn designed Ford's Highland Park plant as a single-story structure, productivity growth jumped from roughly 1.5% to over 5% per year. The factory was built around production flow instead of power delivery.
The same thing is happening with software, and most organizations are still in the early stages. Deloitte's 2026 State of AI report found that only 34% of organizations are truly reimagining their businesses around AI. The rest are optimizing what’s already there.1
In the first phase, roughly 2022 through 2024, AI was layered on top of existing workflows. Teams used tools like ChatGPT in the browser, copying text in and pasting back improved drafts. The workflow stayed the same.
In the second phase, which many organizations are in now, agents moved into the tools themselves. They started completing tasks end-to-end instead of assisting with parts of them. Work moved faster, but the flow, ownership, and decision points didn't change.
The third phase is where it gets hard. Organizations stop structuring work around their tools and start structuring it around outcomes. There is no fixed sequence anymore. The machine evaluates context, makes decisions, and adjusts the flow as it goes. Humans set direction, handle exceptions, and step in when something breaks. Everything else runs autonomously. The roles inside the enterprise shift, too. The administrator job built around approving requests, for example, gives way to analysts setting thresholds and architects designing guardrails.
Nobody has fully built this yet. The organizations that get there first will operate at a cost level most competitors can’t match.
Business logic moves to runtime, and enterprise workflows change with it
When machines couldn't think, precision was everything. If your instructions didn't cover every scenario, the system failed. So we built rules engines with thousands of conditions, workflow platforms to capture edge cases, and approval chains for exceptions.
Now you give the machine direction, context, and guardrails, and it handles what you didn't explicitly define. Building a reporting tool used to mean spending weeks defining every possible view ahead of time. You can give someone a tool that answers questions as they come up.
When logic lives in code, decisions get made upfront by whoever built the application. When it's applied in real time, decisions happen closer to the work itself. Judgment, deep expertise, and the ability to connect dots across unrelated domains become the differentiators. The SaaS application that used to sit in between starts to lose its purpose.
What happens when anyone can build enterprise software?
When anyone can build enterprise software, the bottleneck shifts from technical skill to judgment. People who understand the problem can design the solution. For the first time, building these tools isn't limited by technical skill. I've done it myself, creating tools that would have taken a full development team even two years ago.
But when anyone can build a system this quickly, the questions shift to control. What is it allowed to do? How does it make decisions? Who’s accountable when it’s wrong? We’re moving faster than we can govern, and that creates risk.
Why identity governance is the first security control to fail in the AI age
AI governance breaks first because the tooling wasn't built for real-time decisions. Identity and access policies assume periodic enforcement. I've seen the same pattern over and over in enterprise environments.
You have an Identity Governance and Administration (IGA) product with Segregation of Duties policies loaded that define who can access what, and which combinations create unacceptable risk. The policies are documented, the tool knows the rules, and on paper, you're governed.
However, there's a window, minutes or longer, between when a change happens in a source system and when the IGA product updates what it knows. Access gets provisioned, a conflict appears, and the SoD policy says it shouldn't exist, but the tool doesn't know yet.
Now imagine that same function working differently. The system evaluates requests as they happen. It considers who is asking, why they are asking, the organization’s risk posture, and how similar situations have been handled before. It doesn’t wait for the next sync. It flags conflicts before access is fully provisioned and forces a decision in the moment, whether it’s an error, an exception, or something that needs escalation.
Every decision is recorded with the reasoning behind it. Over time, that creates a history the tool can learn from. The governance gap is still there, but it becomes visible and manageable. Decisions stop being static and start happening in context, as the work happens.
What sits between intent and execution is starting to look like overhead
The layer between intent and execution is becoming overhead
The application layer is the intermediary, and AI is replacing it.
When the machine can take direction, interpret context, and act without that intermediary, much of what sits between intent and execution becomes overhead. The software, sure. But also the approval chains, the integration work that exists only because systems were never designed to talk to each other cleanly.
The organizations I've seen make real progress start with the question, “Which work were humans doing only because the machine couldn't. And what higher-value work could they be doing instead?” Everything else follows from the answer.
Frequently asked questions about agentic AI and enterprise software
Your next read: AI Agents Aren’t Trustworthy (But We’re Deploying Them Anyway
Back to Blog
.png)
.jpg)
