Will AI Agents Shrink Your Software Stack or Just Add Another Layer?

By Victor Hoang · Updated Oct 11, 2026

Every few years a new technology arrives with the promise that it will finally collapse your software stack. Suites were going to do it. Then the cloud. Then low-code. Each time, the stack got bigger anyway.

AI agents are the latest candidate, and the pitch is the most persuasive yet. Instead of logging into six tools to chase one deal, you ask an agent and it does the work across all of them. If that's true, why keep paying for the six?

Here's the position this piece argues, and you can disagree with it: agents will shrink the number of interfaces your people touch, but they will not shrink the number of systems that hold your data. They sit on top of your records. They read from them, write to them, and depend on them being right. So the buying question changes. It's less "which tools can the agent replace" and more "which systems can the agent trust, and how easily can it get in."

The Real Question Behind the Promise

When a vendor says an agent will replace a point tool, they usually mean one of two very different things.

The first is that the agent replaces the screen. A person used to open an app, click through three menus, and copy a result somewhere else. Now they describe the outcome and the agent does the clicking. The app's interface matters less. The app itself, with its data model, permissions and audit trail, still does the work underneath.

The second is that the agent replaces the system. The records, the business rules, and the history all move into a new place, and the old product can be switched off. This is much rarer, and much riskier. It means migrating the thing your finance team, your auditors and your customers' contracts depend on.

Most of what's being sold today is the first kind, described as if it were the second. That gap is where stacks quietly get more expensive instead of cheaper.

What the Data Says About the Stack Today

The stack you'd be shrinking is large, and it isn't shrinking on its own. Zylo's 2026 SaaS Management Index puts the average company at 305 SaaS applications, with application counts down just 0.07% year over year. That's a plateau, not a collapse.

Key Facts

• The average company manages 305 SaaS applications, and application counts declined only 0.07% year over year, according to Zylo's 2026 SaaS Management Index.
• Spending on AI-native SaaS applications rose 108% year over year, and AI was the fastest-growing application category in 2025, per the same index.
• Organizations use an average of 12 AI agents, expected to grow 67% over two years, and 50% of those agents still run in isolated silos, per MuleSoft's 2026 Connectivity Benchmark Report (1,050 IT leaders at large companies).
• 96% of IT leaders say agent success depends on integration across systems.

Read those together and a pattern shows up. The stack is flat, AI spend is growing on top of it, and the agents being deployed are mostly not connected to each other. Nobody is deleting the old layer. They're adding a new one beside it.

The origin of those agents is telling too. In the same MuleSoft research, 36% of existing agents are prebuilt SaaS agents, 34% are embedded in enterprise platforms, and 30% are built in-house. Seven in ten of them arrive inside products you already pay for or on platforms you already run. That's the "another layer" outcome in one number: most agents come attached to an existing system, not as a replacement for one. Whether to take the agent your current vendor bundles or bring in a challenger is its own decision, covered in buying AI from incumbents or AI-native challengers.

Why Records Outlast Interfaces

An agent is only as good as the information it acts on. Ask one to draft a renewal offer, and it needs the contract terms, the usage history, the open support tickets and the discount policy. Those facts live somewhere. They have owners, access rules and a version of the truth that someone is accountable for.

That somewhere is a system of record. Think of your CRM, your ERP, your HRIS, your ticketing system. Their value was never the screens. It was being the one place a fact is authoritative, so that sales, finance and operations aren't arguing over three spreadsheets.

Agents make that authority more valuable, not less. An agent that reads from a messy or duplicated source will produce confident, wrong output at machine speed. The cleaner and better governed the record, the more you can safely let an agent do with it. So the investment that pays off is rarely "another agent." It's the boring work underneath: one customer ID, consistent fields, clear ownership, and sensible permissions.

If you want to see how this plays out in a single function, our piece on how AI agents are changing who builds the shortlist looks at the buying side of the same shift.

Three Things Agents Genuinely Do Retire

None of this means the stack stays frozen. Agents will retire some things, and you should plan for it.

Thin utilities. Tools that exist mainly to move data from one place to another, reformat it, or present it differently are the most exposed. If a product's whole job is a screen over someone else's data, an agent that can reach the data directly is a credible substitute.

Manual coordination. A lot of seats exist because a human has to carry information between systems. When an agent does that carrying, the seat count on the downstream tools can fall. This is part of why seat-based pricing is under pressure, and it's the savings most likely to be real.

Duplicate point solutions. Many organizations pay for overlapping tools in different departments. An agent working across a shared record makes the overlap more visible, which makes it easier to consolidate. Our look at the true cost of software sprawl covers how to find it.

Three Things Agents Do Not Retire

The system of record itself. Your accounting ledger, your customer database and your employee file are not going anywhere because an agent can query them nicely.

Compliance and audit. Regulators and auditors want to know who changed what and when. That history lives in the systems that made the change. An agent adds a new actor to the log; it doesn't replace the log.

Accountability. Someone still owns the number. If the agent acts on a bad record, the cost lands on your business, not on the model.

Where Stack Costs Quietly Rise

Here's the part that rarely makes it into the vendor deck. Adding an agent layer introduces new spend and new risk even when it removes some old spend.

The consumption model is one example. Zylo's index found that 78% of IT leaders reported unexpected charges tied to consumption-based or AI features in the past year, and 77% had discovered AI-powered features or applications operating without IT's awareness. Those two numbers describe a stack that's getting harder to see, not simpler. We cover the budgeting side in how to budget AI spend as pricing shifts from seats to meters.

Integration work is the other one. If 96% of IT leaders say agents only succeed when systems are connected, then the connection layer is where your real project cost sits. A cheap agent that can't reach your data cleanly is a demo. An agent with good access to well-kept records is a tool.

A Decision Framework: Interface, Record, or Layer

Before you approve any agent purchase, sort it into one of three categories. Each has a different buying logic.

Most agent purchases land in the first or third column. If a vendor claims the second, treat it as a platform migration, not a feature rollout, and run it with the same rigor. Our piece on proofs of concept that predict success is a good starting point for how to test that claim before you commit.

What to Buy For

If agents mostly sit on top of records, then the purchase criteria shift. Features still matter, but these matter more.

Open, documented integration. Can the agent read and write through a maintained API, or does it scrape a screen? Does the vendor charge extra for API access? Does it support the standards your other tools use? A product with a closed data model and limited access will become the weak link in every agent workflow you build.

Clean, portable data. Can you export everything, with history, in a usable format? Does the product enforce consistent fields, or does it let every team invent their own? Data you can't move is data an agent can't use well.

Granular permissions. An agent should have the access its task needs and no more. Ask whether the system can scope an agent's permissions separately from a human user's, and whether every agent action is logged against a named identity.

Predictable pricing for agent activity. If the vendor meters agent actions, you need to know the unit, the cap, and the alert. If it bundles them, you need to know what happens at renewal.

Vendor direction you can live with. Is this vendor building agents on top of its own records, or racing to make its records irrelevant? Either can be fine. You just need to know which one you're buying into.

For a structured way to weigh these across vendors, our vendor evaluation framework for AI tools is a reasonable template, and the approval gates and vendor review guide helps with who signs off.

What to Do Next

1. Map your systems of record. List the five to ten places where a fact is authoritative: customers, contracts, employees, inventory, money. Name an owner for each. If you can't, that's your first agent project, and it won't involve an agent.
2. Score each by integration openness. For every system on the list, note whether it offers a maintained API, what access costs, and how permissions work. Anything that scores poorly is a risk to your agent plans, whatever its feature list says.
3. Inventory the agents you already have. Count the ones embedded in products you pay for, the ones teams built, and the ones nobody told IT about. You can't govern a layer you haven't listed.
4. Tag every agent proposal as interface, record or layer. Use the table above. Reject any business case that claims record-level savings from an interface-level change.
5. Pick one seat-reduction claim and test it. Take a vendor's promise that an agent will reduce headcount on a tool, and check the downstream seat count after 90 days. If it didn't drop, the saving wasn't real.
6. Put open access in the renewal checklist. Ask each vendor about API terms, export rights and agent permissions before the next renewal, not after.

The promise that agents will shrink your stack is half right. They will thin out the screens your people work in, and they will make weak, duplicated tools easier to spot. But the databases underneath, and the discipline of keeping them clean and open, become more important the more you ask agents to do. Buy for the records, and the interfaces will sort themselves out.