On this page
Emerging AI Agent Stack: Protocols, Memory & Orchestration
Thirty-one percent of organizations have AI agents in production, but only 10% have deployed them at scale due to infrastructure bottlenecks, not model limitations. The 2026 AI agent stack consists of six core layers, with memory, protocol, and governance gaps as the primary barriers to production deployment. Teams that prioritize vendor-neutral memory and governance over framework selection are best positioned to close the scaling gap.
Thirty-one percent of organizations have an agent in production, yet only 10% have deployed agents at scale. That gap isn’t a model capability problem — it’s an infrastructure problem. The protocols, memory systems, and orchestration layers that turn a demo into a production agent fleet are still maturing, and most teams are stitching them together by hand.
The 2026 AI agent stack has crystallized into six distinct layers between your LLM and a production agent: LLM, orchestration, memory, tools, infrastructure, and evaluation. Understanding how these layers interact — and where the real bottlenecks hide — is the difference between a pilot that ships and one that stalls.
The Protocol Layer: MCP and A2A as Complementary Standards
The protocol landscape consolidated fast. MCP is now the de facto standard for agent-to-tool communication with 97 million monthly SDK downloads and 5,800+ servers as of March 2026. A2A handles agent-to-agent coordination with 150+ organizations adopting it under Linux Foundation governance. These aren’t competing standards — they’re complementary layers. MCP is the vertical bus (agent to tool), A2A is the horizontal bus (agent to agent).
IBM’s Agent Communication Protocol (ACP) consolidated into Google’s A2A under the Linux Foundation in August 2025, which eliminated one of the early sources of protocol fragmentation. The A2A specification reached version 1.0.0/1.0.1 in May 2026 with production-ready SDKs in Python, JavaScript, Java, Go, and .NET. Meanwhile, the MCP 2026-07-28 release candidate makes the protocol stateless by removing the initialize/initialized handshake — a change that simplifies load balancing for remote MCP servers.
There’s also AP2, the commerce layer that handles agent-to-agent payments and transactions as a formal extension of A2A. And the Linux Foundation plans to launch the Agent Name Service (ANS), an open standard giving AI agents trusted identities through DNS, with backing from Cisco and Salesforce.
The practical takeaway: default to MCP for tool access inside each agent, and reach for A2A when workflows span multiple agents or vendors. If you’re choosing between them as alternatives, you’ve already misread the architecture.
For a deeper dive into how these protocols compose in production, see MCP and A2A Together: Building Multi-Agent Systems in 2026.
Memory: The Layer That Determines Whether Agents Scale
Memory became a first-class architectural primitive in 2026, distinct from vector database retrieval. That distinction matters. Traditional RAG treats retrieval as a one-shot lookup. Memory, done right, is a living representation of organizational knowledge that persists across sessions, tasks, and agents.
The problem is acute. Gartner forecasts that fewer than 5% of enterprise applications included task-specific AI agents in 2025, rising to 40% by end of 2026. Yet 75% of organizations are piloting or deploying while only 15% have fully autonomous agents. The gap between “pilot” and “autonomous” is largely a memory problem — agents that can’t retain context across sessions can’t operate without human babysitting.
Three approaches emerged this year:
Engram emerged from stealth with $98M in funding, building a learned memory layer that trains models to anticipate organizational questions in advance. The claim: matching frontier model performance using up to 100x fewer tokens. Early partners include Microsoft, Notion, and Harvey.
Walrus Memory launched as a portable, verifiable memory layer with native MCP support and SDKs for Python and TypeScript. It’s designed for cross-platform portability — agents carry context across apps and sessions without being tied to a single provider.
Perplexity Brain, launched June 19, maintains a source-linked context graph across sessions, tasks, and documents. Every stored fact links back to its originating source, which matters for compliance-sensitive workflows where auditability isn’t optional.
TiDB’s Agent State Stack, announced at SuperAI Summit Singapore, takes a different angle — a unified distributed SQL foundation combining database, persistent memory (mem9), and file workspace (drive9) so agent state lives in one place instead of scattered across systems.
The pattern: memory is no longer an afterthought bolted onto a vector store. It’s the layer that determines whether your agents accumulate institutional knowledge or relearn everything from scratch each session.
Orchestration: Frameworks, Platforms, and the Lock-In Question
The dominant enterprise agentic frameworks in 2026 are LangGraph, CrewAI, Microsoft Agent Framework, Google ADK, and OpenAI Agents SDK. LangGraph has 47M+ monthly downloads and CrewAI has over 52,700 GitHub stars as of June 2026. CrewAI alone is used by 63% of the Fortune 500 and processes over 450 million agentic workflows per month.
On the enterprise platform side, the market has consolidated around three incumbents: Salesforce Agentforce, ServiceNow AI Agents, and Microsoft Copilot Studio. Their pricing models diverge sharply:
| Platform | Pricing Model | Best For | Lock-In Level |
|---|---|---|---|
| Salesforce Agentforce | $2 per conversation | CRM-embedded sales/service agents | High — CRM data model is the foundation |
| ServiceNow AI Agents | $100–150 per user per month (bundled in ITSM tiers) | IT and HR workflow automation | High — Now Platform workflows are the foundation |
| Microsoft Copilot Studio | $200 per tenant per month for 25,000 credits | Internal knowledge agents in M365 shops | Medium-high — M365 tenant, Azure, Power Platform |
A 50-user ServiceNow deployment costs $60,000–$90,000/year in subscription fees alone. But here’s the thing — those license fees are almost irrelevant to your actual TCO. LLM API spend dominates 60–80% of true TCO regardless of platform. The real cost driver is organizational context reconstruction: the tokens burned re-establishing what the agent should already know about your business.
This creates a strange dynamic. Vendors compete on pricing tiers while ignoring the memory bottleneck that prevents production shipping. Enterprises optimize for the wrong line item.
The Governance Gap Nobody Wants to Talk About
The ROI numbers look fantastic on paper — 171% average ROI from agentic AI deployments according to BCG. But only 12% of enterprises have mature AI governance despite 75%+ claiming adoption. Sixty percent of organizations with agents in production lack adequate governance.
Gartner predicts over 40% of agentic AI projects will be canceled by end of 2027 due to escalating costs and inadequate risk controls. That’s not a model problem. It’s an operational infrastructure problem — identity, observability, cost governance, and auditability.
The Linux Foundation’s Agent Name Service is a start, giving agents verifiable identities through DNS. But most enterprises are deploying agents before they’ve solved basic questions: Who authorized this agent? What’s its scope? Can you trace its output to a source document? When something goes wrong, who’s accountable?
What I’d Actually Recommend
Here’s the framework I keep coming back to: decouple framework selection from context architecture strategy. Frameworks are reversible decisions — you can migrate from LangGraph to CrewAI or swap Copilot Studio for Agentforce. But your context architecture is the durable asset that determines whether agents ship to production or remain stuck in pilot.
Standardize on MCP and A2A for interoperability. Invest first in a vendor-neutral organizational memory layer — because the tokens you save by not reconstructing context every session will dwarf any platform license fee. And treat governance as Step 1, not a post-launch cleanup task.
The teams that figure out memory and governance before they obsess over framework selection will be the ones that close the gap between “31% with an agent in production” and “10% deployed at scale.”
The protocol layer is largely solved. The orchestration layer has mature options. The bottleneck is context — and that’s where your attention should go first.