Building towards our multi-agentic future
Tim Sent · Director, Architecture · September 2026
The path from function calling to Agent2Agent, in the order the field actually built it: OpenAI's tool calling, LangChain's standardized interface, Mixture of Agents and the multi-agent frameworks that followed, Anthropic's Model Context Protocol, and Google's Agent2Agent Protocol. The goal is to explain the innovations that led to A2A, and how MCP and A2A work together rather than in competition.
Overview
How OpenAI gave language models a way to take action, and how LangChain standardized it across providers.
Mixture of Agents and the frameworks, LangGraph, CrewAI, MetaGPT, AutoGen, that let multiple agents collaborate.
Anthropic's open standard for how a model reaches tools, resources, and prompts.
Google's open standard for how independent agents discover each other and collaborate as peers.
Agenda, in Reverse Order
Read in reverse chronological order, this mirrors the key developments that led to A2A: each innovation solved a limit the one before it ran into.
June 2023
Tool Calling (Function Calling)
OpenAI introduces tool calling with GPT-3.5-turbo and GPT-4, giving models a structured way to invoke external functions.
July 2023
NANDA
MIT Media Lab begins work on the Networked Agents and Decentralized AI project, exploring agent-to-agent interoperability at scale.
April 2024
LangChain Standardized Tool Calling
A consistent interface for binding tools to any model that supports tool calling, so a tool can be defined once and used across providers.
June 2024
Mixture of Agents (MoA)
Stanford, Duke, and the University of Chicago describe a layered architecture where proposer and aggregator models collaborate to improve a response.
June 2024
Other Multi-Agent Frameworks
LangGraph, CrewAI, MetaGPT, and AutoGen mature into distinct approaches for orchestrating multiple agents.
November 2024
Model Context Protocol (MCP)
Anthropic introduces an open standard for how models access tools, resources, and prompts, later described as the USB-C of AI apps.
March 2025
Building the Internet of Agents: AGNTCY.org
An open collective forms around shared infrastructure for agent discovery, identity, and interoperability across vendors.
April 2025
Agent2Agent Protocol (A2A)
Google introduces an open standard for communication between independent agents built on different frameworks and by different vendors.
From Text to Action
Before tool calling, a large language model could only generate text drawn from its training data. Asked to book a flight, it could describe how to do so, but it had no way to check real availability, no way to take action, and no way to look anything up externally.
A model could understand intent and simulate a plausible answer, but it could not access real-time data, interact with a booking system, or confirm anything against the outside world. Every answer was a guess dressed up as an explanation.
OpenAI introduced tool calling in June 2023 with GPT-3.5-turbo and GPT-4. Developers define tools by name, description, and a JSON schema for their arguments; the model decides when a request matches a tool, and outputs a structured call for the application to execute.
A user asks "What's the weather like in Paris today?" The application and the model exchange five messages to answer it:
get_weather with the appropriate arguments.The tool calling sequence for a single request: the application defines the tool and forwards the message (1), the model calls the tool (2), the application executes it (3) and returns the result (4), and the model turns that result into a final response (5).
Between June 2023 and September 2024, OpenAI, Anthropic, Google DeepMind, Cohere, and Meta all introduced tool calling into their models, each with its own interface. What was missing was a standard. LangChain closed that gap in April 2024 with a consistent interface for binding tools to any model that supports tool calling, defined once with a name, a description, and a JSON schema, and reused across providers.
Multi-Agent Frameworks
Mixture of Experts activates only the most relevant parts of a single large model for a given input, keeping inference cost down as model scale grows. Mixture of Agents applies that same idea across whole models: proposer agents generate candidate responses, and aggregator agents review and refine them into a single, higher quality answer, without any additional training.
Mixture of Experts is a neural network architecture that improves the efficiency and scalability of large neural networks by activating only a subset of the model's components, called experts, for each input. Instead of activating the entire model, only the most relevant experts are used, which reduces computation while maintaining or improving performance, and lets a model scale to billions or trillions of parameters without a linear increase in inference cost.
Sparse Mixture of Experts with Top-1 gating: a small gate network scores every expert for the input, and only the highest scoring expert, FFN2 here at p=0.76, actually processes it. The other three stay idle for this input, which is what keeps inference cost from growing with the number of experts.
The sparse activation encourages expert specialization, so the network handles diverse tasks more effectively, and separating training-time compute from inference-time compute lets large models run efficiently in deployment without losing their capacity to learn complex patterns. A 2025 survey catalogs five further ways to route inputs to experts: BASE Layers, domain mapping with random gating, expert-choice gating, attention routing, and soft MoE, which merges experts instead of selecting one.
Mixture of Agents, described in Wang et al.'s "Mixture-of-Agents Enhances Large Language Model Capabilities," applies the same idea across whole models rather than components within one. It is built as a layered system, where each layer holds several Proposer and Aggregator agents, and each layer takes the output from the previous one and improves upon it.
Each layer's agents take every prior layer's output as input. Proposers generate candidate responses; aggregators review those candidates and produce a refined response, potentially combining or rephrasing them, until the final layer's single aggregator produces the answer.
This architecture encourages modular composition: agents can be heterogeneous, different model sizes or architectures, and configured dynamically. It improves language model performance through structured collaboration between specialized agents, offering better quality, flexibility, and efficiency without additional training.
LangChain and LangGraph have evolved to better support multi-agent systems, while CrewAI and MetaGPT build around the roles each agent takes on in the network.
| Framework | Multi-Agent Capability | Best For |
|---|---|---|
| LangChain | Agent tool use, memory, and control logic via Runnable interfaces | Modular LLM pipelines integrating tools and structured workflows |
| LangGraph | Explicit agent communication and control flow as a directed state graph | Structured multi-agent loops and complex agent interaction flows |
| CrewAI | Human-like roles, researcher, writer, reviewer, operating collaboratively | Document generation and simulated team collaboration |
| MetaGPT | A simulated team of agents, PM, engineer, designer, producing software artifacts | Generating and managing full-stack applications |
| AutoGen | Autonomous, asynchronous dialogue between agents | Dynamic, self-directed collaboration with minimal human prompting |
| ReAct | A thought, action, observation loop within a single agent, embeddable in others | Logic-driven agents capable of iterative reasoning |
The dominant multi-agent design pattern follows the mixture-of-agents model: layered agents that build on and refine each other's output.
Model Context Protocol
Anthropic introduced the Model Context Protocol (MCP) in November 2024 to standardize how AI models interact with external tools, resources, and applications. Before MCP, integrations were custom and inconsistent, requiring teams to rewrite the same logic for every model, platform, or vendor. MCP is a foundational layer for modular, multi-agent, tool-augmented AI systems, often described as the USB-C of AI apps.
Models, tools, and applications can all speak a shared language.
Tools, workflows, and agents are easy to plug in.
Model behavior, tool logic, and application logic stay modular.
One integration supports many AI models and use cases.
Tools are model-controlled functions the model can invoke. Resources are application-controlled data, files, database records, API responses, exposed to the model. Prompts are user-controlled templates for common requests.
Salesforce, SAP, Slack, GitHub, Google Drive, and dozens of other platforms now expose MCP servers, alongside thousands of community servers listed across marketplaces including MCP.so, Smithery.ai, Glama, Cursor Directory, Mastra.ai, and Portkey.ai. Clients include Claude.ai, the Claude Desktop app, Amazon Q, Windsurf, Cursor, and Microsoft Copilot Studio.
Agent2Agent Protocol
Google introduced the Agent2Agent (A2A) Protocol in April 2025 as an open standard for communication between AI agents built on different frameworks and by different vendors. Where MCP connects a model to tools and data, A2A lets independent, opaque agents, each with their own roles, capabilities, and tools, coordinate toward a shared goal without a human in the loop at every step.
Today's most advanced demos still have a person talking directly to an enterprise's agent. A2A points toward a future where consumers have their own agent acting as the go-between, one that can compare several companies' agents and negotiate the best outcome on the person's behalf, exactly the kind of agent-to-agent negotiation A2A is built to carry.
Netting It Out
MCP standardizes how a model accesses tools, data, and dynamic context. A2A standardizes how independent agents communicate, discover each other, and collaborate. In simple terms, MCP is about model-to-resource interaction, and A2A is about agent-to-agent communication. Most agentic systems will need both.
| Model Context Protocol | Agent2Agent Protocol | |
|---|---|---|
| Introduced by | Anthropic, November 2024 | Google, April 2025 |
| Standardizes | Model-to-resource access | Agent-to-agent communication |
| Transport | HTTP, JSON-RPC, Server-Sent Events | HTTP, JSON-RPC, Server-Sent Events |
| Handles | Text, code, documents, structured inputs | Text, audio, video, structured data |
| Core unit | Tools, resources, and prompts | Tasks, Agent Cards, and capabilities |
| Known for | The USB-C of AI apps | Enterprise-grade agent collaboration |
| Adopted by | Over 5,000 servers in the Glama directory | Salesforce, SAP, Workday, and more |
MIT Media Lab's NANDA project, Networked Agents and Decentralized AI, led by Ramesh Raskar, explores agent-to-agent interoperability from a decentralized angle, complementing the more centralized standards from Anthropic and Google.
Resources
Technical Specifications
GitHub Repositories
Papers
Articles & Learning Resources