Two years ago, “AI agents” was a demo category. In 2026 it is operational infrastructure. JPMorgan attributes roughly $2 billion in annual value to its AI program and is preparing long-running autonomous agents for deployment this year. BNY has put 134 “digital employees” into its org chart — each with a manager and something resembling a performance review. Stripe merges more than 1,300 machine-written pull requests every week, with humans reviewing rather than writing the code. And Gartner projects that by the end of 2026, 40% of enterprise applications will embed task-specific agents, up from under 5% a year earlier.
What made this shift possible is not a single breakthrough model. It is the quiet consolidation of an ecosystem: open protocols that any vendor can implement, frameworks that survived a brutal market shakeout, and open-weight models that closed the gap with proprietary frontiers. If you are planning an agent initiative, whether a customer-facing assistant, a back-office compliance workflow, or an internal engineering accelerator, the stack you choose this quarter will shape your options for years.
This article maps the infrastructure layer by layer: the protocols that connect everything, the frameworks and platforms that orchestrate it, and the models that power it. How to run that stack reliably in production, including the engineering discipline and governance around it, is the subject of the second article in this series.
Layer 1: The Protocol Stack — the “HTTP Moment” for Agents
The most consequential story of 2025–2026 is standardization. Until recently, every agent-to-system integration was custom work, and switching model vendors meant rewriting integrations. That era is ending. Three protocol families now define the connective tissue of the agent ecosystem.
MCP: how agents connect to tools and data
The Model Context Protocol (MCP), introduced by Anthropic in November 2024, has become the de facto standard for connecting agents to external systems — databases, APIs, files, SaaS tools. The adoption curve is remarkable by any infrastructure standard: roughly 97 million monthly SDK downloads by March 2026, around 10,000 public servers indexed across registries, and first-party support from Anthropic, OpenAI, Google, Microsoft, GitHub, and virtually every major developer platform.
Just as important, MCP is no longer a single vendor’s protocol. In December 2025, Anthropic donated it to the Agentic AI Foundation under the Linux Foundation, with OpenAI, Google, and Microsoft as co-sponsors. Vendor-neutral governance is precisely what makes it safe to build a multi-year architecture on.
The protocol itself matured fast in 2026:
- A stateless core
The next MCP specification release, scheduled for July 28, is expected to introduce a stateless protocol core, MCP Apps, an extensions framework, and stronger authorization controls.
- MCP Apps
Co-developed with OpenAI, MCP Apps let tools return interactive HTML interfaces rendered in sandboxed iframes: agents can ship dashboards and forms, not just text.
Promoted to stable in mid-2026, EMA replaces per-server consent prompts with centralized, identity-provider-driven access control — the single change that unblocks MCP for many regulated deployments, including financial services.
What it means for your project: wrap your internal systems in MCP servers once, and every agent — regardless of vendor or framework — can use them. This is the highest-leverage integration investment available today.
A2A: how agents talk to each other
Where MCP connects an agent to tools, the Agent2Agent (A2A) protocol connects agents to agents. Launched by Google in April 2025 and donated to the Linux Foundation two months later, A2A reached version 1.0 in April 2026 with more than 150 supporting organizations and production deployments in financial services, insurance, supply chain, and IT operations. IBM’s competing Agent Communication Protocol voluntarily merged into A2A in 2025, effectively ending the standards contest at this layer.
The v1.0 release addressed the concerns enterprises actually raised: cryptographically signed AgentCards, so an orchestrator can verify a peer agent is who it claims to be; multi-tenancy for SaaS providers; and formal version negotiation. Microsoft ships A2A support in Copilot Studio and Azure AI Foundry; AWS supports it in Bedrock AgentCore.
What it means for your project: multi-agent architectures — an orchestrator delegating to specialist workers — no longer lock you into one framework. An agent built on LangGraph can delegate to an agent running inside a vendor platform, over a documented, neutral protocol.
The agentic commerce stack: when agents spend money
The newest and most contested protocol layer governs agents that transact. Traditional payment rails assume a human pressed the buy button; agents break that assumption, and 2025–2026 produced a rapid, overlapping series of answers:
- AP2 (Agent Payments Protocol) — Google’s mandate-based trust layer, built on cryptographically signed proofs that a human authorized a purchase. Launched with 60+ partners and transferred to the FIDO Alliance in May 2026 for neutral governance.
- ACP (Agentic Commerce Protocol) — OpenAI and Stripe’s checkout protocol using scoped, single-use Shared Payment Tokens.
- UCP (Universal Commerce Protocol) — announced in January 2026 by Google, Shopify, Walmart, Target, and others; covers the full journey from discovery to post-purchase.
- Network-level programs — Mastercard Agent Pay and Visa’s Trusted Agent Protocol / Intelligent Commerce, which by April 2026 accepted payments across ACP, UCP, and MPP through a single integration.
- Machine-to-machine rails — Coinbase’s x402, now under Linux Foundation stewardship, and Stripe’s Machine Payments Protocol for stablecoin-settled micropayments between services.
Two practical conclusions follow for teams building payment or commerce products. First, these standards often operate at different layers of the same transaction. UCP may coordinate product discovery and checkout, while AP2 may capture delegated authority. A payment network or machine-payment protocol may then handle credentials and settlement. Teams should therefore design for interoperability rather than assume that one protocol will cover the entire transaction lifecycle.
Second, infrastructure maturity does not guarantee consumer adoption. OpenAI scaled back its original Instant Checkout model in March 2026, showing that protocol availability alone is not enough to create a competitive shopping journey. Checkout UX, merchant coverage, channel economics, and consumer trust still need to be validated.
Layer 2: Frameworks and Platforms — After the Shakeout
The framework landscape consolidated dramatically over the past twelve months, and older comparison articles will actively mislead you. Here is the current state of play.
LangGraph remains the most production-hardened open-source choice for stateful, regulated workloads. It reached 1.0 GA in October 2025 and carries the largest verified enterprise deployment list — Klarna, Uber, LinkedIn, BlackRock, and JPMorgan among them — with checkpointing, durable execution, and human-in-the-loop primitives that matter when an agent touches customer money or regulated data.
Microsoft Agent Framework is the story of the year on the Microsoft side. In late 2025, Microsoft merged AutoGen and Semantic Kernel into a single SDK, which reached v1.0 GA for both Python and .NET in April 2026. AutoGen — the default multi-agent recommendation of 2024 — is now in maintenance mode. Starting a new project on it in 2026 means starting on a deprecated path.
CrewAI holds the rapid-prototyping lane with role-based crews and reported adoption across a majority of the Fortune 500. A common pattern: teams prototype in CrewAI and migrate to LangGraph when workflows outgrow role-based simplicity.
Vendor SDKs became first-class options. The OpenAI Agents SDK, Anthropic’s Claude Agent SDK, and Google’s ADK (now at 2.0, with native A2A support) each offer a lower-friction path when a single agent with a few tools is all you need — often skipping the framework abstraction tax entirely.
The 2026 agent framework decision table
| Criteria | LangGraph | Microsoft Agent Framework | CrewAI | Google ADK 2.0 |
| Best for | Complex, long-running workflows with persistent state, branching, and approval steps | Enterprise and multi-agent systems, especially in organizations using Azure, Entra ID, or .NET | Rapid prototyping and role-based multi-agent workflows | Hierarchical and distributed multi-agent systems, especially A2A-native architectures |
| Languages | Python, TypeScript | Python, .NET | Python | Python, TypeScript, Java, Go |
| Protocol support | MCP through official integrations; A2A through documented integrations | Native MCP and A2A | MCP and A2A supported | Native A2A; MCP supported |
| Self-hosting | Yes | Yes | Yes | Yes |
| Managed option | LangSmith Deployment, including cloud, BYOC, and enterprise self-hosting | Azure AI Foundry | CrewAI AMP, available in cloud and on-premises environments | Vertex AI Agent Engine |
| License | MIT | MIT | MIT open-source core | Apache 2.0 |
| Core strengths | Checkpointing, durable execution, replay, branching, persistent workflow state, and human-in-the-loop controls | Enterprise identity integration, multi-agent orchestration, Python and .NET support, and close integration with Microsoft infrastructure | Role-based crew abstractions, rapid setup, and straightforward multi-agent coordination | Native A2A support, hierarchical orchestration, broad language coverage, and support for multiple model providers |
| Main trade-off | Detailed workflow control requires more engineering and operational effort | Runs outside Azure, but delivers its deepest enterprise integrations within the Microsoft ecosystem | Role-based abstractions may require additional orchestration design as workflow state, branching, and recovery become more complex | Supports multiple model providers, while its deepest managed deployment and observability integrations remain within Google Cloud |
Managed platforms: when an integrated ecosystem matters
Managed agent platforms combine orchestration with deployment, identity, connectors, access controls, monitoring, and evaluation. The main options include Salesforce Agentforce, Microsoft Copilot Studio, Google’s Gemini Enterprise Agent Platform, Amazon Bedrock AgentCore, and IBM watsonx Orchestrate.
Their main advantage is ecosystem integration. Agentforce connects agents with Salesforce data and workflows. Copilot Studio integrates with Microsoft 365, Power Platform, and Entra ID. Google’s platform adds managed runtime, IAM, governance, and observability. Bedrock AgentCore supports different frameworks and models with managed runtime, authentication, tracing, and evaluation.
These platforms suit companies already using the same vendor stack and looking to reduce infrastructure work. They can speed up internal assistants, customer-service automation, and repeatable business workflows.
The trade-off is less architectural flexibility. Moving to another cloud, replacing platform-specific components, or customizing the runtime may require additional work. Costs also shift toward platform and usage fees.
A hybrid model is often practical: managed platforms for standardized workflows, open frameworks for agents that need custom state, deeper runtime control, portability, or specialized security boundaries.
Layer 3: Models — Open Weights Close the Gap
The model layer changed just as quickly. In 2026, open-weight models became competitive with proprietary systems across selected coding, reasoning, multimodal, and agent benchmarks.
DeepSeek V4 arrived in April 2026 as a preview release with two mixture-of-experts variants. V4-Pro has 1.6 trillion total parameters with 49 billion activated per token, while V4-Flash has 284 billion total parameters with 13 billion activated. Both support a one-million-token context window.
Alibaba released Qwen 3.5 in February 2026, starting with the 397B-parameter Qwen3.5-397B-A17B mixture-of-experts model. The model is natively multimodal, supports 201 languages and dialects, and is available under Apache 2.0.
Z.ai’s GLM-5.2 reached 62.1 on SWE-Bench Pro in the company’s published evaluation, leading the open-weight models included in that comparison and outperforming some proprietary systems. Other self-deployable options include Moonshot AI’s Kimi K2 family, MiniMax M3, and Meta’s Llama 4 line.
Together with serving engines such as vLLM and SGLang, these models make fully self-managed agent stacks technically viable. Their license terms differ, however: the group includes Apache 2.0, MIT-derived, modified MIT, and vendor-specific community licenses. Open weights therefore do not automatically mean unrestricted commercial use.
For regulated industries, the impact extends beyond data residency. It also changes inference economics. A common production pattern is model routing: larger models handle planning and complex reasoning, while smaller models process classification, extraction, test generation, and evaluation tasks.
Routing can reduce costs, but the result depends on workload distribution, context length, model pricing, and the quality threshold each task must meet.
Mixture-of-experts architectures improve the same economics by activating only part of a model for each token. DeepSeek V4-Pro, for example, activates 49 billion of its 1.6 trillion parameters, while V4-Flash activates 13 billion of 284 billion.
What This Means for Your Stack Decisions
Compressing the above into decisions you can act on this quarter:
1. Standardize on MCP and A2A now. Both are Linux Foundation-governed and supported by every major vendor. Adopting them keeps your vendor and framework options open — and wrapping your core systems in MCP servers is the single best-leveraged integration investment of 2026.
2. Choose frameworks by deployment context, not GitHub stars. LangGraph for stateful, regulated production. Microsoft Agent Framework if you live on Azure and .NET. CrewAI for fast prototyping. Vendor SDKs for simple single-agent cases. Avoid starting anything new on AutoGen or standalone Semantic Kernel.
3. Design for model routing from day one. Pair a frontier model with cheap open-weight workers, and reassess your model shortlist quarterly. Routing is an architecture decision — retrofitting it after the fact is expensive.
The Stack Is Necessary — but Not Sufficient
Everything above makes agents possible: protocols make integration cheap, frameworks make orchestration cheap, open models make inference cheap. None of it makes an agent reliable.
The teams shipping agents to production — the ones behind Stripe’s 1,300 weekly PRs or JPMorgan’s move from pilots to hundreds of use cases — will tell you the same thing: the model is only half the system. The other half is everything around it — the context it receives, the tools and constraints it operates within, the independent checks that verify its output, and the governance that decides how much autonomy it earns. In the emerging shorthand of the field: Agent = Model + Harness.
That harness — and the engineering discipline of building it — is the subject of the second article in this series: How to Build Reliable AI Agents for Production: Context, Harness, and Loop Engineering.
Building an agent initiative on top of payment systems, digital banking, lending, or compliance workflows raises questions this article can only sketch — least-privilege tool design for financial data, audit trails that satisfy regulators, and where the human checkpoint belongs when money moves. These are the problems our team works on daily. If you’re mapping your own 2026 agent roadmap, we’re happy to compare notes.