There is a layer in every enterprise that knows more about how the business actually works than any system of record. It isn't the CRM. It isn't the ERP.
It's the context layer : the accumulated record of decisions, exceptions, approvals, and precedents that explains not just what happened across systems, but why it was allowed to happen.
Every enterprise runs on two things. Rules, what should happen in general. And decision traces, what actually happened in a specific case, under what conditions, approved by whom, and why an exception was granted. The VP who approved a 20% discount on a Zoom call. The compliance ruling that changed how one vertical gets handled. The precedent set two years ago that still quietly governs how edge cases get resolved today.
None of that lives in any system of record. Systems of record capture the outcome. They never capture the reasoning. The CRM shows the final price. It doesn't show who approved the deviation or why. The ERP shows the transaction. It doesn't show the exception logic that allowed it.
That missing layer: the decision trace, the precedent, the why is what actually runs the enterprise. And it has never had anywhere to live except in people's heads.
AI agents are now entering this layer. And the question is whether they'll finally build what no software before them could: a deep contextual and business understanding of how an enterprise actually operates.
Integration Context: The Decision Record Nobody Captured
Every enterprise integration is, underneath the field mappings and trigger conditions, a fossil record of decisions.
Why does the finance team's revenue recognition sync fire at a different point in the pipeline than supply chain's procurement workflow? Because a CFO and a VP of Operations disagreed about when a sale was a sale, and someone configured the integration to reflect the compromise they landed on. Why does the financial vertical get different exception handling than everyone else? Because a compliance audit flagged a gap, an SI consultant rewired three mappings to close it, and that logic has been quietly governing revenue recognition ever since.
None of this is documented. None of it is queryable. It exists as organisational memory, distributed across the people who were in the room when those decisions were made, the consultants who translated those decisions into configuration, and the escalation threads that resurface every time a connector breaks.
This is what integration context actually is: not the shape of data in motion, but the reasoning that produced that shape. The business logic encoded in every custom field. The exception rules that reflect how a particular vertical actually operates. The approval chains that determined which system wins when two records conflict.
Integration services became a bigger business
Because iPaaS platforms built the infrastructure. But infrastructure that can't read the business it's connecting has a ceiling.
That ceiling is where system integrators built their businesses. Accenture, Deloitte, Wipro, and a generation of boutique integration consultancies scaled to multi-billion dollar businesses — and it wasn't because enterprises needed someone to configure Mulesoft. They scaled because every enterprise integration project eventually hit the same wall: the platform could move data, but it couldn't understand why the data needed to move that way.
The SI's value was never the code. It was the process of acquiring enterprise context and translating it to implementations.This included sitting with the customer
- Reading the schema
- Decoding the custom objects
- Vertical-specific rules
- Understanding the approval logic that no documentation captured
Finally encoding that understanding into a connector that actually reflected how the business ran.
That knowledge never transferred back to the platform. It lived inside the SI's delivery team. Which is precisely why the same customer called the same SI for the next integration, and the one after that, acting as a great land and expand motion for SIs alongside more forwar integrations into reconciliations and reporting use cases along side maintenances & fixes for these integrations. Not because switching was hard. Because the SI was the only party that remembered why the last connector was built the way it was.
The result: integration services became a bigger business than integration software and Saas overall as every new Saas application came with an added cost of implementing & maintaining it. The platform built the pipes. The services firm captured the context. And in enterprise software, context is where the durable value lives.
The entire SI industry is, structurally, a workaround for a missing software layer.
Agents will capture what iPaas could never
The reason iPaaS couldn't build the context layer isn't a failure of ambition. It's an architectural constraint.
iPaaS was designed around canonical schemas — Salesforce's standard Account object, SAP's standard Customer record. The assumption baked in: two instances of the same application are functionally equivalent. Map the fields, fire the trigger, sync on schedule. The platform doesn't need to understand the business. It just needs to move the data correctly.
But enterprise software is almost definitionally customised. The more successfully a company deploys Salesforce or SAP or Workday, the more its instance diverges from the canonical schema — and the more a generic connector misses what actually matters.
An Account with a custom field called Strategic_Tier isn't a schema artifact. It's evidence of a tiered account strategy, of downstream workflows that depend on that tiering, of business logic that any integration touching that object needs to understand. A connector that ignores it because it isn't in the spec isn't just incomplete. It's operating on a model of the business that doesn't exist.
Agents don't start from the canonical schema. They start from the actual one. They read the schema as a primary source: inferring the business logic encoded in every custom object, every non-standard relationship, every exception rule. They capture why a particular mapping was configured the way it was, who approved the configuration, what changed upstream when something breaks. And critically: they persist all of it.
Every integration becomes a decision trace. Every decision trace becomes context. Every deployment adds to a growing graph of organisational knowledge that makes the next integration faster, more accurate, and less dependent on a consultant who remembers what happened last time.
This is the compounding property iPaaS never had. It moved data reliably. It learned nothing from doing so.
The Implication
The enterprises moving fastest over the next five years won't be the ones with the most connectors. They'll be the ones whose integration layer has finally become what it always was in practice but never was in software: a living record of how the business actually works.
For CTOs at software companies selling into enterprise, this reframes the integration problem at its root. The constraint was never bandwidth — more engineers, more SI capacity, more iPaaS licenses. The constraint was always context. Understanding a customer's schema deeply enough to build an integration that reflects their operational reality, not a generic approximation of it.
The SI industry was built on that constraint. AI agents are the first technology positioned to dissolve it — not by automating the configuration, but by finally treating integration context as first-class data. Capturing it. Persisting it. Compounding it across every deployment.
The pipes were never the product. They were just what got built while the real layer waited.
Last Updated: Apr 16, 2026
