hidekazu-konishi.com

Tool Use and Agent Protocol History and Timeline - Function Calling, MCP, and A2A

First Published: 2026-07-05
Last Updated: 2026-07-05

This is a non-AWS installment in my history-and-timeline series, where I have previously tracked the evolution of individual AWS services and foundation model families. This time, I have built a single timeline for one of the most consequential shifts in applied AI: how large language models learned to use tools, and how the agent protocols that coordinate those tools - function calling, the Model Context Protocol (MCP), and the Agent2Agent (A2A) protocol - came into existence.

The question "when did LLMs become able to use tools?" is asked constantly by developers, agent researchers, and technical writers, yet there is no single canonical reference that answers it with primary sources. This article is my attempt at that reference. It follows the story from the research precursors of 2022, through OpenAI function calling and Anthropic tool use, to computer use, and then to the two open protocols that now structure the agent ecosystem: MCP (which connects a model to tools and data) and A2A (which connects agents to other agents). Every row in the timeline links to a primary source - each vendor's official announcement or documentation, the MCP and A2A specification repositories, or the original papers.

This article focuses on the announcements, general-availability milestones, specification revisions, and major adoptions that define the history of tool use and agent protocols. It is not an implementation tutorial, a performance comparison, or a pricing guide; those are covered in my dedicated MCP and Amazon Bedrock AgentCore articles.

Companion articles on hidekazu-konishi.com:

• Anthropic Claude Model Release Timeline - Model Family Tree, Capability Evolution, and Platform Availability
• OpenAI GPT Model Release Timeline
• Agent Interoperability Architecture with A2A and MCP on AWS
• MCP Server Ecosystem Reference 2026

Background and Method of Creating the Tool Use and Agent Protocol Timeline

The reason for creating this timeline is that the "tool" and "agent protocol" layer of modern AI has evolved extremely quickly and across many vendors, and the primary facts are scattered across separate company blogs and specification repositories. It is genuinely difficult to keep a mental map of "when did function calling arrive?", "when was MCP announced versus when was each specification revision published?", and "when did A2A move to the Linux Foundation?". I wanted one page that organizes these facts chronologically, with a primary source for each one.

Two terms are used throughout this article, and it is worth defining them precisely:

• Tool use (also called function calling) is the ability of a model to invoke external functions, APIs, or - in the case of computer use - graphical interfaces, by emitting a structured request that the application executes on the model's behalf.
• An agent protocol is an open standard that governs how these capabilities are wired together. The Model Context Protocol (MCP) standardizes how an agent reaches tools and data (a vertical, model-to-tools relationship). The Agent2Agent (A2A) protocol standardizes how agents discover and delegate work to each other (a horizontal, agent-to-agent relationship).

To organize this history, I have taken the following approaches.

• Tracking the history of tool use and agent protocols and organizing the transition of updates.
• Summarizing the current overall picture of function calling, MCP, and A2A.

The inclusion criteria are deliberately explicit. Announcements, general availability, specification revisions, and major platform adoptions are each recorded as separate rows, so that "announced", "generally available", and "specification revision N" are never conflated. Protocol and feature names use each vendor's own period-correct wording.

The source policy is primary-only. This timeline references each vendor's official blog and documentation, the MCP and A2A specification repositories and changelogs, and the original research papers. Dates from secondary media are not used as the source of record. Where a primary source states only a month (for example, a "v1.0 released in March" statement), the timeline reflects that precision rather than inventing a specific day. This is a vendor-neutral record: each company's contribution is stated as a fact, without ranking or ideological evaluation.

This timeline primarily references the following sources.

• Anthropic News
• OpenAI News
• Google Developers Blog
• Model Context Protocol Specification
• Agent2Agent (A2A) Protocol
• What's New with AWS

There may be slight variations in the dates on this timeline due to differences between the original announcement, general availability on a given platform, and the specification revision label. The dates below prioritize the original announcement date when more than one exists.
The content posted here is limited to the milestones considered essential for understanding the history of tool use and agent protocols.
In other words, please note that the items on this timeline are not all updates in this area, but are representative milestones that I have picked out.

Tool Use and Agent Protocol Historical Timeline (Updates from October 6, 2022)

Here is the chronological timeline of the major milestones in tool use and agent protocols, from the research precursors of 2022 through the protocol maturation of 2026. Each row links to the official announcement, specification, or paper.

* You can sort the table by clicking on the column name.

Date	Event
2022-10-06	The ReAct paper introduces interleaved reasoning and acting for language models. ReAct (Reason + Act) shows that prompting a model to alternate between reasoning traces and actions lets it call external sources such as a Wikipedia API - an early template for tool-augmented and agentic LLMs. Source: ReAct: Synergizing Reasoning and Acting in Language Models.
2023-02-09	Meta AI publishes Toolformer, showing that language models can teach themselves to call APIs. Toolformer is trained in a self-supervised way to decide which API to call (calculator, search, question answering, translation, calendar), when to call it, and with what arguments. Source: Toolformer: Language Models Can Teach Themselves to Use Tools.
2023-03-23	OpenAI announces ChatGPT plugins. The alpha release lets ChatGPT use first-party tools (a web browser and a code interpreter) and third-party plugins, alongside an open-sourced retrieval plugin - the first widely used productized "tools for a language model". Plugins were later retired in 2024 in favor of GPTs. Source: ChatGPT plugins.
2023-06-13	OpenAI introduces function calling in the API. Developers can describe functions to gpt-4-0613 and gpt-3.5-turbo-0613, and the model returns a JSON object with arguments to call them - the first mainstream "function calling" API primitive. Source: Function calling and other API updates.
2023-11-06	OpenAI introduces JSON mode at its first DevDay. JSON mode constrains the model to emit syntactically valid JSON (though not yet a specific schema), a building block for reliable tool integrations, alongside the Assistants API. Source: New models and developer products announced at DevDay.
2023-11-21	Anthropic adds tool use as a beta with Claude 2.1. Claude 2.1 introduces a 200K-token context window, system prompts, and an initial beta of tool use (function calling) on the Anthropic API. Source: Claude 2.1.
2024-05-30	Anthropic makes tool use generally available on Claude 3. After entering public beta across the Claude 3 family in April 2024, tool use (function calling) reached general availability on Claude 3 Opus, Sonnet, and Haiku across the Claude API, Amazon Bedrock, and Google Cloud Vertex AI. Source: Tool use is now generally available.
2024-05-30	AWS launches the Amazon Bedrock Converse API with standardized tool use. The Converse API provides a single consistent interface across foundation models and supports Tool use (function calling) for supported models, standardizing function calling on Amazon Bedrock. Source: Amazon Bedrock Converse API (AWS What's New).
2024-08-06	OpenAI introduces Structured Outputs in the API. Structured Outputs guarantees that model output conforms to a developer-supplied JSON Schema, both via the response_format parameter and via strict function calling (strict: true), building on the earlier JSON mode. Source: Introducing Structured Outputs in the API.
2024-10-22	Anthropic releases computer use as a public beta. Announced together with an upgraded Claude 3.5 Sonnet and Claude 3.5 Haiku, computer use lets Claude perceive a screen and control a mouse and keyboard, extending tool use from APIs to graphical interfaces. Source: Introducing computer use, a new Claude 3.5 Sonnet, and Claude 3.5 Haiku.
2024-11-05	The Model Context Protocol specification is first revised (version 2024-11-05). MCP uses date-based version identifiers; 2024-11-05 is the initial specification revision, defining the client-server model, JSON-RPC messaging, and the tools, resources, and prompts primitives. Source: MCP specification 2024-11-05.
2024-11-25	Anthropic announces and open-sources the Model Context Protocol (MCP). MCP is an open standard that lets AI applications connect to external data and tools through a uniform interface, released with Python and TypeScript SDKs and reference servers for Google Drive, Slack, GitHub, Git, and Postgres, among others. Source: Introducing the Model Context Protocol.
2025-03-19	Microsoft introduces MCP in Copilot Studio. Microsoft added MCP support to Copilot Studio (initially available in preview regions), letting makers connect agents to existing knowledge servers, APIs, and other MCP-enabled data sources. Source: Introducing Model Context Protocol (MCP) in Copilot Studio.
2025-03-26	OpenAI adopts MCP, starting with the Agents SDK. OpenAI added MCP support to its Agents SDK, with ChatGPT desktop and the Responses API to follow - the first adoption of the standard by another frontier AI lab. Source: Model context protocol (MCP) - OpenAI Agents SDK.
2025-03-26	The MCP specification is revised (version 2025-03-26). The revision adds an OAuth 2.1-based authorization framework, replaces the HTTP+SSE transport with the more flexible Streamable HTTP transport, and adds tool annotations, audio content, and argument completion support. Source: MCP specification 2025-03-26 changelog.
2025-04-09	Google commits Gemini models and its SDK to MCP. Google DeepMind CEO Demis Hassabis announced that Gemini models and the Gemini SDK would support MCP; native SDK support followed at Google I/O in May 2025. Source: Demis Hassabis on supporting MCP for Gemini.
2025-04-09	Google announces the Agent2Agent (A2A) protocol. A2A is an open standard that lets agents discover, authenticate, and delegate tasks to other agents across frameworks, launched at Google Cloud Next with more than 50 partners. Where MCP connects agents to tools, A2A connects agents to agents. Source: Announcing the Agent2Agent Protocol (A2A).
2025-05-19	Microsoft makes MCP a first-class standard across its platforms at Build 2025. Microsoft announced broad first-party MCP support spanning GitHub, Copilot Studio, Dynamics 365, Azure AI Foundry, Semantic Kernel, and Windows 11, and Microsoft and GitHub joined the MCP steering committee. Source: Microsoft Build 2025: The age of AI agents and building the open agentic web.
2025-05-21	OpenAI adds remote MCP server support to the Responses API and joins the MCP steering committee. The Responses API can now call tools hosted on any remote MCP server, and OpenAI joined the protocol's steering committee. Source: New tools and features in the Responses API.
2025-06-18	The MCP specification is revised (version 2025-06-18). The revision adds structured tool output, elicitation (servers requesting additional input from users), and resource links in tool results; classifies MCP servers as OAuth Resource Servers; and removes JSON-RPC batching. Source: MCP specification 2025-06-18 changelog.
2025-06-23	Google donates A2A to the Linux Foundation. At the Open Source Summit North America, Google contributed the A2A specification, SDKs, and tooling to the new Linux Foundation Agent2Agent project, formed with Amazon Web Services, Cisco, Google, Microsoft, Salesforce, SAP, and ServiceNow for vendor-neutral governance. Source: Linux Foundation launches the Agent2Agent protocol project.
2025-07-16	AWS announces Amazon Bedrock AgentCore in preview. AgentCore is a set of services - Runtime, Memory, Gateway, Identity, Browser, Code Interpreter, and Observability - for building and operating agents at scale with any framework, with support for MCP and A2A. Source: Amazon Bedrock AgentCore now available in preview.
2025-09-08	The official MCP Registry launches in preview. The MCP Registry is an open catalog and API for publicly available MCP servers, designed as a federated "metaregistry" to improve discovery across the ecosystem. Source: Introducing the MCP Registry.
2025-10-13	Amazon Bedrock AgentCore reaches general availability. AgentCore GA (across nine AWS Regions) adds A2A protocol support in AgentCore Runtime, while AgentCore Gateway connects to existing MCP servers and transforms APIs and Lambda functions into MCP-compatible tools behind a single secure endpoint. Source: Amazon Bedrock AgentCore is now generally available.
2025-11-25	The MCP specification is revised (version 2025-11-25), the one-year anniversary release. This release adds long-running tasks (asynchronous operations), migrates to JSON Schema 2020-12, introduces an extensions framework, and simplifies authorization - marking MCP's first anniversary. Source: One Year of Model Context Protocol: the 2025-11-25 spec release.
2025-12-09	Anthropic donates MCP to the newly established Agentic AI Foundation. Anthropic donated the Model Context Protocol to the Agentic AI Foundation (AAIF), established at the Linux Foundation and co-founded by Anthropic, Block, and OpenAI with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. The announcement states that MCP's governance model remains unchanged, with the project's maintainers continuing to prioritize community input. Source: Donating the Model Context Protocol and establishing the Agentic AI Foundation.
2026-03	The Agent2Agent protocol reaches v1.0. In March 2026, A2A Protocol v1.0 - described by Google as the first stable, fully production-ready version - added signed Agent Cards, multi-tenancy, and version negotiation from the earlier v0.3. Source: A year of open collaboration: Celebrating the anniversary of A2A.
2026-04-09	The Linux Foundation reports A2A adoption by more than 150 organizations at its first anniversary. One year after launch, the Linux Foundation announced that the A2A protocol was supported by over 150 organizations and in enterprise production use across major cloud platforms. Source: A2A Protocol surpasses 150 organizations.

There may be slight variations in the dates in this timeline due to differences between announcement, general availability, and specification revision labels. The dates above prioritize the original announcement date when more than one exists.

Current Overview of Tool Use and Agent Protocols

Having followed the chronology, this section summarizes the current overall picture: the function-calling APIs that let a single model use tools, the two open protocols (MCP and A2A) that structure the wider agent ecosystem, how they relate, and how they are supported on AWS.

Function Calling and Tool Use

Tool use is now a standard capability across the major model providers, exposed through slightly different API shapes:

• OpenAI exposes function calling (the model returns arguments for developer-defined functions) and Structured Outputs, which constrains output to a supplied JSON Schema, including strict function calling via strict: true.
• Anthropic exposes tool use through the Messages API, where a developer supplies tool definitions and the model returns a tool_use request that the application executes and returns as a tool_result. Computer use extends this to controlling a screen, mouse, and keyboard.
• Amazon Bedrock exposes the Converse API, a single interface across foundation models whose Tool use (function calling) support standardizes the pattern across multiple providers.

The common shape is the same across providers: the developer declares tools with a name, description, and JSON Schema for the input; the model decides when to call a tool and returns a structured request; the application runs the tool and returns the result for the model to continue.

Provider	API surface	Tool-use mechanism
OpenAI	Chat Completions and Responses API	Function calling, plus Structured Outputs for strict JSON Schema conformance (including strict function calling).
Anthropic	Messages API	Tool use via tool_use and tool_result content blocks; computer use extends this to graphical interfaces.
Amazon Bedrock	Converse API	Unified Tool use (function calling) across supported foundation models behind one interface.

Model Context Protocol (MCP)

MCP standardizes the connection between an AI application and the tools and data it uses, so that a single integration works across any compliant client. Its core concepts are:

• Architecture: an MCP host (the AI application) runs one or more MCP clients, each of which connects to an MCP server that exposes capabilities.
• Primitives: servers expose tools (callable functions), resources (readable context such as files or records), and prompts (reusable prompt templates).
• Transports: local servers use stdio; remote servers use the Streamable HTTP transport introduced in the 2025-03-26 revision.
• Versioning: MCP uses date-based specification versions - 2024-11-05, 2025-03-26, 2025-06-18, and 2025-11-25 - each of which is listed with its own changelog.
• Discovery: the official MCP Registry (preview since 2025-09-08) provides a shared catalog of publicly available MCP servers.

In practice, an MCP session begins with an initialize handshake in which the client and server negotiate the protocol version and capabilities; the client then discovers what the server offers (for example, by listing its tools) and issues typed JSON-RPC calls such as a tool invocation, receiving structured results in return. Because the handshake and message shapes are standardized, the same MCP server works unchanged across any compliant host - whether a Claude, OpenAI, Google, or Microsoft client - which is precisely what lets a single integration be reused everywhere.

The specification has been revised on a roughly quarterly cadence. The table below consolidates the four published revisions and their headline changes.

Version	Headline changes
2024-11-05	Initial specification: the client-server model, JSON-RPC messaging, and the tools, resources, and prompts primitives. Source: MCP 2024-11-05.
2025-03-26	An OAuth 2.1-based authorization framework, the Streamable HTTP transport (replacing HTTP+SSE), tool annotations, audio content, and argument completions. Source: MCP 2025-03-26 changelog.
2025-06-18	Structured tool output, elicitation, resource links in tool results, MCP servers classified as OAuth Resource Servers, and removal of JSON-RPC batching. Source: MCP 2025-06-18 changelog.
2025-11-25	One-year anniversary release: long-running tasks (asynchronous operations), migration to JSON Schema 2020-12, an extensions framework, and simplified authorization. Source: MCP 2025-11-25 release.

Agent2Agent (A2A) Protocol

A2A standardizes how independent agents - potentially built by different teams on different frameworks - discover one another and collaborate. Its core concepts are:

• Agent Cards: a machine-readable description (served at a well-known path) that advertises an agent's identity, skills, and endpoints; v1.0 adds cryptographically signed Agent Cards.
• Tasks and messages: agents exchange tasks with a defined lifecycle over JSON-RPC, with support for streaming results.
• Governance: A2A is hosted by the Linux Foundation (since June 2025) and reached a stable v1.0 in March 2026.

In a typical A2A interaction, a client agent first retrieves a remote agent's Agent Card to learn its skills and endpoint, then sends it a task; the remote agent works through a defined task lifecycle and can stream intermediate updates and artifacts back over JSON-RPC. Because A2A rides on ordinary HTTP and JSON-RPC rather than a special-purpose transport, it works with existing load balancers, gateways, and authentication infrastructure - the same design choice that MCP made with its Streamable HTTP transport.

How MCP and A2A Relate

MCP and A2A are complementary rather than competing, and together they form a two-layer reference model. MCP is the vertical axis - it gives a single agent its "hands", connecting a model to tools and data. A2A is the horizontal axis - it lets a team of agents coordinate with each other. An agent is typically an MCP host (using MCP to reach its tools) and, at the same time, an A2A peer (using A2A to delegate to and receive work from other agents). The table below contrasts the two protocols at a glance.

Dimension	Model Context Protocol (MCP)	Agent2Agent (A2A)
What it connects	An agent to tools and data	An agent to other agents
Direction	Vertical (agent to its tools)	Horizontal (agent to agent)
Core units	Tools, resources, prompts	Agents, Agent Cards, tasks
Transport	stdio (local) and Streamable HTTP (remote), over JSON-RPC	HTTP with JSON-RPC, with streaming
Originator	Anthropic (November 2024)	Google (April 2025)
Governance	Agentic AI Foundation at the Linux Foundation (since December 2025), with a steering committee and the MCP Registry	Linux Foundation Agent2Agent project

This two-layer base has been extended by additional protocols built on A2A's extensibility model, such as AG-UI (for agent-to-user-interface interaction) and AP2 (the Agent Payments Protocol); these build on, rather than replace, the MCP-and-A2A foundation.

Support on AWS

On AWS, the same two layers map onto Amazon Bedrock AgentCore. AgentCore Gateway connects to existing MCP servers and turns APIs and AWS Lambda functions into MCP-compatible tools behind one secure endpoint, covering the MCP (agent-to-tools) layer. AgentCore Runtime hosts A2A servers - passing JSON-RPC payloads through to the agent container and exposing Agent Cards at the standard well-known path - covering the A2A (agent-to-agent) layer. At the model level, the Amazon Bedrock Converse API provides standardized tool use across foundation models. For deeper coverage, see my Agent Interoperability Architecture with A2A and MCP on AWS and Amazon Bedrock AgentCore beginner's guide.

Frequently Asked Questions about Tool Use and Agent Protocol History

When did OpenAI introduce function calling?

OpenAI introduced function calling on 2023-06-13, when it added the capability to the gpt-4-0613 and gpt-3.5-turbo-0613 models, allowing the model to return a JSON object with arguments for developer-defined functions.

When was the Model Context Protocol announced?

Anthropic announced and open-sourced the Model Context Protocol (MCP) on 2024-11-25. The specification itself uses date-based version labels, and its initial revision is dated 2024-11-05. The subsequent specification revisions are 2025-03-26, 2025-06-18, and 2025-11-25.

What is the difference between MCP and A2A?

MCP and A2A operate on different axes and are complementary. MCP (Model Context Protocol) connects a single agent's model to tools and data - a vertical, model-to-tools relationship. A2A (Agent2Agent) connects agents to other agents so they can discover each other and delegate tasks - a horizontal, agent-to-agent relationship. An agent is often an MCP host and an A2A peer at the same time.

When did computer use capabilities appear?

Anthropic released computer use as a public beta on 2024-10-22, announced together with an upgraded Claude 3.5 Sonnet and Claude 3.5 Haiku. Computer use lets the model perceive a screen and control a mouse and keyboard, extending tool use from APIs to graphical interfaces.

Who maintains MCP and A2A now?

MCP was created by Anthropic and donated on 2025-12-09 to the Agentic AI Foundation (AAIF), established at the Linux Foundation and co-founded by Anthropic, Block, and OpenAI; per the announcement, MCP's governance model remains unchanged, with a steering committee that other vendors (including OpenAI, which joined in May 2025) participate in, plus the community-driven MCP Registry. A2A was donated by Google to the Linux Foundation on 2025-06-23 and is governed there as the Agent2Agent project; it reached a stable v1.0 in March 2026 and, at its first anniversary in April 2026, was reported to be supported by more than 150 organizations.

When did tool use become generally available on the Claude API?

Anthropic made tool use generally available on 2024-05-30 for Claude 3 Opus, Sonnet, and Haiku, across the Claude API, Amazon Bedrock, and Google Cloud Vertex AI. It had first appeared as a beta with Claude 2.1 on 2023-11-21.

How does Model Context Protocol versioning work?

MCP uses date-based version identifiers in the form YYYY-MM-DD, which mark the last date on which backwards-incompatible changes were made rather than a sequential version number. The published revisions are 2024-11-05, 2025-03-26, 2025-06-18, and 2025-11-25, each of which has its own changelog.

When did the major AI platforms adopt MCP?

Microsoft introduced MCP in Copilot Studio on 2025-03-19, OpenAI adopted MCP in its Agents SDK on 2025-03-26, Google committed its Gemini models and SDK to MCP on 2025-04-09, Microsoft made MCP a first-class standard across its platforms (including Windows, GitHub, and Azure AI Foundry) at Build 2025 on 2025-05-19, and AWS added MCP and A2A support in Amazon Bedrock AgentCore (preview on 2025-07-16, generally available on 2025-10-13).

Summary

In this article, I created a historical timeline of tool use and agent protocols and summarized the current overall picture of function calling, MCP, and A2A.

The timeline shows three phases: a 2022-2023 phase in which research (ReAct, Toolformer) and early products (ChatGPT plugins, OpenAI function calling, Anthropic tool use) established that a language model can call external tools; a 2024 phase in which structured outputs and computer use hardened tool use and Anthropic introduced the Model Context Protocol; and a 2025-2026 phase in which MCP was adopted by OpenAI, Google, Microsoft, and AWS and revised on a regular cadence, while the Agent2Agent protocol was announced, moved to the Linux Foundation, and reached a stable v1.0. The result is a two-layer model - MCP for connecting a model to tools and data, and A2A for connecting agents to each other - that now structures how AI agents are built.

By organizing these milestones in one place with a primary source for each, I hope this article serves as a reference that AI search agents, developers, and researchers can consult in a single fetch.

This timeline will be updated as tool use and agent protocols continue to evolve.

In addition, there are related history-and-timeline articles on this site, so please have a look if you are interested.
AWS History and Timeline - Almost All AWS Services List, Announcements, General Availability(GA)
Anthropic Claude Model Release Timeline - Model Family Tree, Capability Evolution, and Platform Availability
OpenAI GPT Model Release Timeline
AWS History and Timeline regarding Amazon Bedrock - Overview, Functions, Features, Summary of Updates, and Introduction

References:
Introducing the Model Context Protocol (Anthropic)
Model Context Protocol Specification
Agent2Agent (A2A) Protocol
OpenAI: Function calling and other API updates
Amazon Bedrock AgentCore is now generally available
MCP Server Testing and Debugging Guide
MCP Server Config Builder and Validator (Tool)
Anthropic Tool Use Schema Builder and Validator (Tool)

References:
Tech Blog with curated related content