The Middleware Squeeze: What Happens to Integration Tools When Agents Wire Themselves Together

Table of Contents

• What the Middleware Layer Actually Does
• Why Agents Threaten the Connector Business
• The Squeeze From Both Ends
• Where iPaaS Vendors Are Repositioning
• The New Integration Stack in a GaaS World
• What Buyers Should Actually Do
• Insights Most People Overlook
• References

What the Middleware Layer Actually Does

Strip away the marketing and integration middleware solves three unglamorous problems. It moves data between systems that were never designed to share it. It transforms that data so the receiving system understands it, dates, currencies, field names, nested objects. And it babysits the whole thing: retries when an API times out, alerts when a sync breaks, audit logs for when finance asks why a number is wrong.

That's the work behind every "Salesforce-to-NetSuite connector" and every "when a Stripe payment succeeds, update the CRM" automation. Companies like MuleSoft (now Salesforce), Boomi, Workato, Tray, Celigo, and the workflow-automation crowd led by Zapier built large businesses on it. The pricing models tell you what they were really selling: per-connector fees, per-task consumption, per-seat licenses for the builders, and platform tiers gated by volume.

Here's the part worth holding onto. Most of that value wasn't the data movement itself, HTTP requests are free. The value was knowing how to wire it correctly: which field maps to which, what the rate limits are, how to handle the half-success where 800 of 1,000 records went through. That knowledge got encoded into pre-built connectors and templates, and customers paid for not having to rediscover it. The connector was a frozen artifact of an integration engineer's afternoon.

Agents melt that artifact.

Why Agents Threaten the Connector Business

An LLM-driven agent that can read an OpenAPI spec, reason about two schemas, and write the mapping on the fly does, in a few seconds and for the cost of some tokens, a chunk of what a pre-built connector charged a subscription for. The connector encoded one engineer's solved mapping. The agent re-derives the mapping each time it's needed, adapts when the API changes, and doesn't need a human to publish a new connector version when Salesforce renames a field.

Three shifts compound the threat.

The connector library stops being a moat. Vendors used to brag about "300+ pre-built connectors." That number was a buying signal: the more connectors, the less custom work you'd do. But if an agent can integrate against any documented API, the marginal value of the 301st connector approaches zero. The library becomes a convenience, not a lock-in. The emergence of the Model Context Protocol as a standard way to expose tools and data to agents accelerates this, when every system ships an MCP server, the agent doesn't need a vendor's proprietary connector at all.

Per-task pricing inverts. iPaaS consumption pricing assumed a human designed the flow once and it ran millions of times. Agentic integration is messier and often cheaper at low volume: the agent figures out the integration for a one-off task and never builds a persistent pipeline. A lot of "integrations" were really one-time data migrations or occasional reconciliations dressed up as recurring flows. Those evaporate into a single agent run.

The buyer changes. This is the quiet one, and it echoes the broader pattern across this cluster, the same dynamic playing out in how agents change the buyer inside the enterprise. Integration platforms were sold to integration teams and IT. When a line-of-business operator can say "pull these two reports together and flag the mismatches" to an agent, IT's gatekeeping role over the glue layer weakens. The budget for "integration" starts migrating toward the budget for "agents," which is a labor-shaped line item, not a software one.

The Squeeze From Both Ends

The word "squeeze" is deliberate. Middleware isn't facing a single replacement threat; it's getting compressed from two directions at once, and the middle is the part that disappears.

From below, commoditization of simple glue. The bread-and-butter integration, move a record from A to B, transform a few fields, fire on an event, is exactly what a competent agent handles unsupervised. This is the high-volume, low-complexity tier that fed a lot of seat counts and task consumption. Foundation models keep getting cheaper and better at structured reasoning, so this floor keeps rising. The implication mirrors the displacement of low-code and no-code tools by agents: the visual flow-builder was a way to let non-engineers express integration logic, and natural language is a faster interface to the same intent.

From above, the trust and governance ceiling. Here's the counterintuitive part: agents make the hard parts of integration harder, not easier. When a deterministic connector moves data, you can reason about it. It does the same thing every time. When an agent decides the mapping at runtime, you've introduced non-determinism into your financial reporting pipeline. Now you need: schema-change detection, output validation, lineage tracking, the ability to replay what the agent did and why, permission boundaries so the agent can't read or write where it shouldn't, and a kill switch. This is governance, observability, and reliability work, and it's growing, not shrinking. It connects directly to the data-access wars where SaaS vendors gatekeep agent integrations: someone has to broker and police what the agent is allowed to touch.

So the simple glue gets commoditized away, the governance layer expands, and the classic middle, the curated connector catalog with a flow designer, is the squeezed zone. That's the part most exposed.

Where iPaaS Vendors Are Repositioning

Watch what the incumbents actually do, not what they say in keynotes. The credible plays I'm seeing fall into a few buckets.

Become the runtime, not the connector. Instead of selling pre-built integrations, sell the governed environment agents execute integrations in, the place where credentials are vaulted, every agent action is logged, rate limits are enforced, and outputs are validated before they touch a system of record. Workato's and Boomi's moves toward "agentic" orchestration layers are bets on owning the control plane rather than the glue. This is the smartest available pivot, and it rhymes with the broader system-of-record versus system-of-action battle: middleware is repositioning as the trusted system-of-action substrate.

Sell the connectivity, not the connector. There's durable value in maintained, authenticated, rate-limit-aware access to thousands of endpoints. Agents still need somewhere to land their API calls safely. A vendor that maintains hardened, observable, permission-scoped access to every SaaS API, and exposes it to agents via a standard interface, sells the rails even as the glue commoditizes. This is the Zapier/Tray hedge, and it's why the contest with workflow-automation incumbents like Zapier is more nuanced than a simple replacement.

Move up into reliability-as-a-service. Gartner's analysts have repeatedly flagged that integration and automation are converging into a single platform category, and the agent era pushes that convergence toward a reliability product: SLAs on agent-executed workflows, drift detection, and remediation. That's a higher-margin story than connector subscriptions and harder for a thin wrapper to replicate.

The vendors at real risk are the ones whose entire pitch was "we have the most connectors and the easiest drag-and-drop builder." That's precisely the squeezed middle.

The New Integration Stack in a GaaS World

Picture the stack reorganizing around the agent rather than the pipeline.

At the bottom sits standardized tool access, MCP servers, well-documented APIs, and capability registries that tell an agent what a system can do and how to call it. This layer is becoming a commodity standard, which is good for everyone except vendors who sold proprietary access to it.

In the middle sits the agent runtime and orchestration, where the agent plans the integration, calls tools, and handles multi-step workflows. This is where a lot of former middleware value is migrating, and where GaaS providers sell outcomes ("reconcile these systems daily") rather than infrastructure ("here's a pipeline you maintain").

Wrapping all of it is the governance and trust plane, identity and permissions for agents, audit and lineage, validation, cost controls, and human-in-the-loop checkpoints. This is the growth tier, and it's where I'd put money. The pattern where an agent simply does the workflow the SaaS used to host only works in production if this plane is solid; otherwise you've automated your way into an unauditable mess.

Notice what's missing from the center of this picture: the curated connector catalog as a standalone product. It doesn't vanish, but it demotes from "the product" to "a feature of the runtime."

What Buyers Should Actually Do

If you run integration or platform engineering, a few practical moves follow from all this.

Stop signing multi-year deals priced on connector count or builder seats without an agent-era exit. The metric that mattered, how many pre-built integrations a vendor offers, is depreciating. Negotiate for consumption flexibility and the right to point agents at the platform's connectivity layer.

Separate the two things you're actually buying: connectivity (authenticated, maintained access to endpoints) and logic (the mappings and workflows). Connectivity is durable and worth paying for. Logic is increasingly something an agent generates, so paying a premium for someone else's frozen logic is a shrinking proposition.

Invest early in the governance plane, because it's the part you can't shortcut. The organizations that get burned will be the ones that let agents wire systems together with no lineage, no validation, and no permission boundaries, and then discover a silent data-quality problem three quarters later. Treating agent integrations as opex labor that still needs supervision, the way the cluster's CFO reframing of agents as opex labor rather than software spend describes, keeps the accounting honest and the controls funded.

And run the build-versus-buy math fresh. A surprising number of "we need an iPaaS for this" problems are now a contained agent task with good observability around it. Not all, high-volume, latency-sensitive, deterministic pipelines still want real middleware. But the default has shifted.

Insights Most People Overlook

The connector library was always a depreciating asset, agents just accelerated the write-down. Every pre-built connector is a bet that an API won't change. APIs change constantly, and vendors spend enormous unseen effort maintaining connectors against drift. Agents that re-derive mappings on the fly aren't just cheaper; they're structurally more resilient to API churn. The "300+ connectors" boast was always partly a maintenance liability dressed as an asset.

Non-determinism is the real product opportunity, not the bug. Everyone frames agentic integration's randomness as a problem. The vendor that reframes it as a managed property, "we make non-deterministic integration auditable and reliable", owns the most defensible position in the stack. The money isn't in making agents integrate; it's in making it safe to let them.

MCP and similar standards hurt iPaaS incumbents more than they hurt SaaS apps. When a SaaS vendor ships its own MCP server, it disintermediates the middleware layer that used to sit between it and the customer. The app keeps its data moat; the middleman loses its reason to exist for that connection. Integration vendors quietly have more to fear from open tool-access standards than the application vendors do.

The squeeze creates a barbell, and the middle-market iPaaS is the loser. Simple integration goes to agents and free standards. Complex, governed, high-stakes integration goes to a thicker reliability platform. The mid-tier "easy connectors plus a flow builder" product, historically the most popular tier, is exactly what gets hollowed out. If your revenue concentrates there, that's the number to watch.

"Number of integrations live" stops being a health metric. Investors and operators have long tracked active integrations as a stickiness signal. In the agent era, a falling count of standing pipelines can be a sign of health, work moving to on-demand agent runs, not churn. Misreading that metric will cause some avoidable panic, the same way seat-count shrinkage is being misread across SaaS.

References

• Anthropic, Introducing the Model Context Protocol
• Gartner, Application Integration and Automation Insights