What Agents Can't Replace
In my last post, Your AI Agent Is Building Shadow IT, I argued that agents are starting to create a new layer of software inside companies. This post continues that line of thinking to what changes when that happens.
There’s been a lot of discussion about AI eating SaaS. Satya Nadella called business apps “CRUD databases with business logic” and said the logic is moving to the AI layer. Nicolas Bustamante says he doesn’t log into his SaaS tools anymore because his agent does it for him. They’re both pointing at something real: agents are going to hollow out a lot of the interaction layer of software.
But that does not mean they replace the coordination layer.
Once agents can operate software directly, a lot of what felt valuable about a product turns out to have been the interface. Agents will increasingly build their own interfaces on the fly, even if users aren’t fully aware of what those agents are doing behind the scenes. They’ll assemble whatever UI or workflow is needed to get a job done, calling APIs with the user’s credentials, pulling data across systems, even using the user’s browser. That UI your SaaS team spent years polishing is needed less and less by humans, and will see less and less direct use.
But if you think about the basic requirements of doing work as a group, they do not go away. People still need to agree on what’s true, agree on what words mean, know who’s responsible for what, and track who did what and why. Every organization that has ever existed needed these things, long before software. Everyone having a personal AI agent doesn’t change that. It just changes the way it looks.
What becomes more valuable is the core: the shared state, rules, configuration, permissions, and audit trail that let an organization operate without stepping on itself. The part that answers questions like: what is true right now, who is allowed to change it, what counts as approved, what does this field mean here, and who did what last.
Those things are easy to underestimate because they live in the least glamorous part of the product. Settings. Config. Schemas. Roles. Validation rules. Approval chains. The admin panel, basically. Not because it is glamorous, but because that is where organizations encode what is allowed, what is required, and what counts as done. Teams tend to treat that layer like support machinery behind the real product. In the agent era, that balance flips.
Agents make convenience layers easier to replace. They make systems that enforce shared truth harder to live without.
Having an army of agents in your company increases the value of systems that encode shared organizational rules, state, and accountability. That is not “workflow” in the loose sense people often mean it. It is closer to codified policy. There’s a reason large companies don’t just track everything in spreadsheets. Spreadsheets can store and transform data, but what they can’t do is enforce who approves what, what values are valid, which version is current, or which record is authoritative. That’s what the app layer actually provides, and agents need it just as much as humans did.
And if that sounds abstract, imagine the alternative. Give a company a hundred agents and take away Salesforce. Three teams contact the same customer. A discount gets offered that should have required approval. One workflow writes to a stale export while another reads from the live record. A dashboard gets generated from the wrong source and no one notices because the person who used to know the workaround is no longer in the loop. It would be pure chaos.
Rohit Krishnan recently tested a version of this: in his experiments simulating agents inside an organizational environment, adding more agents without shared coordination state degraded performance. More agents made things worse, not better. The shared state wasn’t an optimization. It was a prerequisite.
Agents peel away the edge and expose the core.
What to do about it
Every SaaS product team, especially teams building for enterprise, should be thinking about these questions:
If an agent became the primary user of your product tomorrow, what would still matter? Your dashboards and navigation probably wouldn’t. Your data model, permissions, validation logic, and approval chains probably would.
Do you actually enforce truth anywhere? If an agent needs to know who owns the Anderson account, what discount tier a customer qualifies for, or whether a deal has been approved, do they have to come to you? Storing the record is not enough. The durable value is in enforcing which record is current, who can change it, what values are valid, and what counts as approved.
Can agents participate in your coordination layer, or only your interaction layer? Can they check permissions before acting, route something for approval, validate a field value, read your schema, or interact through a stable machine-usable contract? Or do all of those things require a human clicking through a settings page? If your rules only exist as UI affordances, agents will be slowed down or won’t be able to follow them reliably.
When fifty agents and twenty humans are all working against the same system, does your product prevent them from contradicting each other? Conflicting updates, duplicate outreach, unauthorized changes, stale data treated as current. These are the problems that shared state, validation rules, and audit trails exist to solve. They get harder with more actors, not easier.
Somebody still has to decide what’s true, what’s allowed, and who’s responsible. That was always the job of policy and configuration, even when it was buried in a settings page nobody designed well. The companies that make that layer clear, accessible, and agent-ready are the ones that will matter when everything above it gets rebuilt every week.
