The report identifies a mindset trap that's holding most organizations back: "inside-out" integration thinking.

Inside-out means viewing integration from the perspective of only prioritizing the reuse of legacy integrations and architecture (i.e., simply wrapping existing integrations with MCP and calling it agent-ready) and forcing the agent to work within that paradigm. It's the natural instinct for teams that have spent years deploying iPaaS or managing brittle, scattered APIs with manual registration and configuration change workflows, inadequate documentation, and no clear ownership. 

This perspective sounds like: “Build another connector, develop many layers of 'orchestration logic,' and just sweep the legacy APIs under the carpet of 'agentic' workflows." The instinct there might be to layer the agents on top of this type of hard-coded, DSL-driven, business logic and low-quality APIs by simply wrapping them with MCP–without thinking from the agent’s perspective first.

The problem is that this approach treats agents as just another consumer of existing services. It doesn't account for what agents actually need: the ability to autonomously navigate across systems, discover relevant tools at runtime, maintain context across multi-step workflows, and take actions on behalf of users with proper authorization.

Gartner contrasts this with "outside-in" integration — starting from the agent's goal and the user's needs, then architecting the internal technology environment to support that journey. Outside-in means building delegated identity so agents can act with proper authorization. It means real-time data foundations, so agents aren't reasoning on stale information. It means hybrid connectivity that combines dynamic discovery with deterministic reliability. 

The shift from inside-out to outside-in isn't incremental. It's architectural. And it explains why traditional integration approaches — including iPaaS—will struggle in the agentic era.

Here's something we've been saying for a while: traditional iPaaS is dying. Not because integration doesn't matter: it matters more than ever. But because of the rigid, connector-based, point-to-point integration, hardcoded flow model that iPaaS represents is fundamentally inside-out.

iPaaS was built for a world where integration meant connecting known systems through pre-built connectors. Source system A connects to target system B through connector C. The integrations are static, the endpoints are known in advance, and the patterns are deterministic.

Agentic AI breaks every one of these assumptions:

• Agents need dynamic discovery, not static connectors. An agent tasked with resolving a customer issue might need to access order management, inventory, shipping, and CRM systems—but which systems and in what order depends on the specific problem. Pre-wired connectors can't handle this.
• Agents need real-time context, not batch synchronization. iPaaS excels at scheduled data movement. Agents need to reason on current, real-time state. Gartner explicitly calls this out: "AI agents cannot reason effectively on day-old data."
• Agents need delegated identity, not static credentials. iPaaS typically authenticates with service accounts or API keys. Agents acting on behalf of users need OAuth 2.1-based token exchanges that maintain an auditable delegation chain.
• Agents need multi-protocol fluency, not just REST. The agentic stack includes APIs, events, MCP, and agent-to-agent protocols. iPaaS platforms built around REST connectors can't provide unified governance across this surface area.

This is why Gartner's call for a "context mesh" matters. It's not a better version of iPaaS. It's recognition that agentic AI requires a fundamentally different integration architecture — one that starts from agent goals rather than existing system boundaries.

Gartner's prescription is what they call a "real-time context mesh," an integration layer that enables agents to securely discover state, reason across systems, and trigger actions seamlessly within and across platforms.

This context mesh has several essential characteristics:

• Hybrid connectivity: MCP for dynamic tool discovery in uncertain environments, combined with traditional APIs for deterministic consistency. Gartner notes that the MCP developer community created over 16,000 MCP servers in 2026 alone — but production deployments need more than raw discovery. They need reliability, governance, and the ability to scope toolsets appropriately.
• Delegated identity: Moving beyond static API keys to OAuth 2.1-based token exchanges that authorize agent actions based on auditable human consent. Gartner predicts that inadequate identity controls will contribute to 25% of security breaches by 2028.
• Separated communication paths: Distinct protocols and controls for agent-to-model (reasoning), agent-to-environment (tool execution), and agent-to-agent (collaboration) traffic. Each path has different risk profiles and requires different governance.
• Scoped toolsets: What Gartner calls the "Back end for Agent" (BFA) pattern—deploying targeted facades that expose only the specific tool metadata and permissions required for a given agent's mission. This prevents context window overload and improves reasoning accuracy.
• Real-time foundations: Modernizing batch-based systems into event-driven architectures. This is the antithesis of iPaaS-style scheduled synchronization.

This is a significant departure from both traditional API management and traditional iPaaS. It's not about exposing endpoints or wiring connectors — it's about architecting an environment where autonomous systems can operate safely and effectively.

Reading Gartner's research, what struck us was how closely their "context mesh" aligns with what we've been calling AI connectivity. And it's exactly what we’ve built here at Kong.

AI connectivity is the unified governance and runtime layer that spans the full data path agents traverse — from APIs and events to LLM calls, MCP connections, and agent-to-agent communication. It provides consistent visibility, control, and policy enforcement across every protocol in the agentic stack.

The components map very nicely:

Gartner's research includes a prediction that should focus attention:

Gartner provides a seven-phase roadmap for outside-in integration, from defining cognitive architecture through deployment and continuous evaluation. The phases are useful, but the practical question for most organizations is: what infrastructure do I need to make this real?

Based on our work with enterprises building AI connectivity programs, here's where to focus:

• Start with visibility across the full AI data path. You can't govern what you can't see. Map how agents are connecting today—to models, to APIs, to MCP servers, to each other. Most organizations discover significant shadow AI activity in this exercise.
• Unify your gateway layer. The separated communication paths Gartner recommends (agent-to-model, agent-to-environment, agent-to-agent) shouldn't mean three separate gateway products with three separate policy engines. Unify them under a single control plane with consistent policy enforcement.
• Build for hybrid connectivity from day one. MCP adoption is accelerating, but APIs aren't going away. Your infrastructure needs to handle both — with the ability to scope toolsets appropriately for different agents and use cases.
• Implement delegated identity at the infrastructure layer. OAuth 2.1 OBO flows shouldn't be something every agent team implements independently. Build it into the platform so authorization is consistent and auditable across every deployment.
• Meter everything. Cost visibility and monetization both depend on granular usage data. Build metering into your connectivity infrastructure so you can attribute costs, enforce budgets, and eventually price AI-powered capabilities.
• Retire the iPaaS mindset. If you're still thinking in terms of connectors and batch synchronization, you're thinking inside-out. The context mesh requires real-time, dynamic, multi-protocol infrastructure — not more pre-wired integrations.

This is what your Agentic AI Developer Platform will enable—a unified environment where teams can build, run, discover, govern, and monetize agents on a foundation that delivers Gartner's context mesh requirements.

This is exactly what we've built with Kong Konnect. Here’s a quick overview:

• Hybrid connectivity: Kong handles MCP, REST, GraphQL, gRPC, Kafka, and AI-native traffic (MCP, LLMs, agent-to-agent, etc.) through a single platform. Agents can discover tools dynamically while still relying on deterministic APIs for core system interactions. No connectors required.
• Unified governance: Policies are defined once and enforced consistently across every traffic type. PII redaction, rate limiting, access controls, and audit logging happen at the infrastructure layer — not through manual review processes that slow deployment.
• Separated but unified communication paths: Agent-to-model, agent-to-environment, and agent-to-agent traffic flow through different gateway capabilities but share a common control plane. You get the separation Gartner recommends without the fragmentation of multiple point products.
• Developer self-service: Developer portals provide the service catalog and semantic metadata that let both humans and agents discover available capabilities that are specific to their intended purpose and goals. The BFA pattern Gartner recommends becomes practical when discovery is built into the platform.
• Cost visibility and monetization: Metering can be built into the platform and runtime offerings, enabling the cost-per-interaction tracking and usage-based billing that sustainable AI programs require.

Gartner's context mesh is the destination. Kong's AI connectivity platform is how you get there — without the limitations of iPaaS or the fragmentation of point solutions.

The research predicts that by 2027, over 50% of AI agents deployed in enterprises will rely on standardized frameworks like MCP or A2A for secure, cross-system interoperability. The organizations building this infrastructure now will be ready. The organizations still treating agents as just another API consumer — or trying to wire them through iPaaS connectors — will be rebuilding from scratch.

The context mesh isn't optional. It's the integration architecture that agentic AI requires. The question is whether you build it deliberately through an AI connectivity program — or discover its absence when your AI initiatives hit the 40% failure rate Gartner warns about.

We've been calling it AI connectivity. Gartner calls it the context mesh. Either way, it's time to build it.

*All cited Gartner research is from “How to Enable Agentic AI via API-Based Integration,” by  Adrian Leow, Mark O'Neill, and Keith Guttridge. Published January 10, 2026.