Anthropic Donates Model Context Protocol to Agentic AI Foundation Under Linux Foundation

In a landmark move that promises to reshape the future of artificial intelligence interoperability, Anthropic has announced the donation of the Model Context Protocol (MCP) to the newly established Agentic AI Foundation, operating under the governance of the Linux Foundation. This historic decision, made in collaboration with co-founders Block (formerly Square) and OpenAI, marks a pivotal moment in the evolution of AI agent development and cross-platform connectivity.

The announcement has sent ripples throughout the technology industry, as three of the world's most influential AI organizations have joined forces to establish an open, vendor-neutral standard for AI agent communication. With MCP already achieving an astounding 97 million monthly SDK downloads and powering over 10,000 active servers worldwide, this transition to open governance ensures that the protocol's future development will be guided by community consensus rather than corporate interests.

According to the GitHub Blog, this represents "one of the most significant open source contributions in the AI space to date," positioning MCP as the de facto standard for building AI tools and agents that can seamlessly interact with external systems, data sources, and services.

Understanding the Model Context Protocol: The Universal Language for AI Agents

The Model Context Protocol, originally developed by Anthropic in late 2024, addresses one of the most fundamental challenges in modern AI development: enabling large language models (LLMs) to interact meaningfully with external tools, databases, APIs, and services. Before MCP, each AI application required custom integration code for every external system it needed to access, creating a fragmented ecosystem that hindered innovation and increased development costs.

MCP introduces a standardized, open protocol that defines how AI models communicate with "context servers" that provide access to external capabilities. As described on Wikipedia, the protocol operates on a client-server architecture where MCP clients (typically AI assistants or agents) connect to MCP servers that expose specific functionalities through a well-defined interface.

The elegance of MCP lies in its simplicity and universality. Rather than requiring AI developers to build custom connectors for each tool or data source, they can simply integrate an MCP client that automatically discovers and utilizes any MCP-compatible server. This architectural approach transforms the integration landscape from O(n*m) complexity to O(n+m), dramatically reducing the engineering effort required to build powerful, capable AI agents.

The Agentic AI Foundation: A New Era of Collaborative Governance

The Agentic AI Foundation emerges as a new entity under the Linux Foundation's umbrella, designed specifically to govern standards and protocols essential for the development of autonomous AI agents. The foundation's establishment represents an unprecedented collaboration between competitors who recognize that certain infrastructure must be developed openly for the entire industry to thrive.

Co-Founders: An Unprecedented Alliance

The three co-founding organizations bring complementary strengths and perspectives to the foundation:

Supporting Organizations

Beyond the co-founders, the Agentic AI Foundation has attracted support from an impressive roster of technology leaders who will contribute to the protocol's development and governance:

• Google: The search giant and creator of Gemini brings massive infrastructure expertise and has committed to MCP support in their AI products
• Microsoft: The developer of Copilot and Azure AI services, bringing enterprise-scale deployment experience and developer tooling expertise
• Amazon Web Services (AWS): The world's largest cloud provider, ensuring MCP compatibility across the AWS AI and machine learning ecosystem
• Cloudflare: Edge computing and security specialist, contributing expertise in distributed systems and secure protocol implementation
• Bloomberg: Financial data and technology leader, representing enterprise use cases in regulated industries

Founding Projects: Building Blocks for the Agentic Future

The Agentic AI Foundation launches with three foundational projects, each contributed by one of the co-founding organizations. Together, these projects provide a comprehensive foundation for building, deploying, and managing AI agents.

1. Model Context Protocol (MCP) - Contributed by Anthropic

The cornerstone of the foundation, MCP provides the communication protocol that enables AI agents to interact with external tools and services. The protocol specification includes detailed documentation, reference implementations in multiple programming languages, and a growing ecosystem of pre-built servers for common integrations.

As reported by The New Stack, MCP's adoption has accelerated dramatically since its initial release, with the protocol now serving as the integration layer for some of the world's most widely used AI applications.

2. goose - Contributed by Block

Goose is an extensible AI agent framework developed by Block that demonstrates how MCP can be used to build sophisticated, production-ready AI agents. The framework provides a complete development environment for creating agents that can perform complex tasks across multiple systems.

Key features of goose include automatic tool discovery through MCP, support for multiple LLM backends, built-in safety guardrails, and extensive logging and debugging capabilities. Block has deployed goose internally for various automation tasks, proving its reliability at enterprise scale.

3. AGENTS.md - Contributed by OpenAI

AGENTS.md introduces a standardized file format for describing AI agent capabilities and requirements. Similar to how robots.txt provides instructions for web crawlers, AGENTS.md allows developers and organizations to specify how AI agents should interact with their systems, services, and content.

The specification covers authorization requirements, rate limiting expectations, preferred interaction patterns, and capability descriptions. This standard ensures that AI agents can discover and respect the policies set by service providers, fostering responsible and predictable agent behavior.

Explosive Growth: MCP by the Numbers

The decision to transition MCP to the Agentic AI Foundation comes at a time of unprecedented growth for the protocol. The statistics paint a picture of a technology that has achieved remarkable adoption in a remarkably short timeframe.

These numbers reflect not just download counts but active usage. The 10,000+ active servers represent production deployments processing millions of requests daily, enabling AI agents to access databases, execute code, manage files, interact with APIs, and perform countless other operations through a unified interface.

Industry-Wide Adoption: MCP Becomes the Standard

Perhaps the most significant indicator of MCP's success is its adoption by major AI platforms. The protocol has transcended its origins at Anthropic to become a truly cross-platform standard, supported by competing AI assistants and development tools.

AI Assistants with Native MCP Support

• ChatGPT (OpenAI): Full MCP support enables ChatGPT users to connect to external tools and data sources, extending the assistant's capabilities beyond its training data
• Claude (Anthropic): As the protocol's originator, Claude features the most mature MCP implementation with support for all protocol features
• Gemini (Google): Google's multimodal AI assistant has integrated MCP to enable seamless connection with third-party services and enterprise systems
• Microsoft Copilot: Microsoft's AI assistant uses MCP to integrate with enterprise systems, Microsoft 365, and third-party applications

Developer Tools with MCP Integration

• Cursor: The AI-powered code editor leverages MCP to provide contextual coding assistance, connecting to documentation, codebases, and development tools
• Visual Studio Code: Microsoft's popular editor includes built-in MCP support, enabling AI extensions to access project context and external services
• JetBrains IDEs: IntelliJ IDEA, PyCharm, and other JetBrains tools have adopted MCP for their AI-powered features

Technical Deep Dive: How MCP Works

Understanding the technical architecture of MCP helps clarify why it has achieved such widespread adoption. The protocol is designed with simplicity, security, and extensibility as core principles.

Core Concepts

MCP operates on a client-server model with four primary concepts:

• Tools: Functions that AI agents can invoke to perform actions, such as querying a database, sending an email, or executing code
• Resources: Read-only data that provides context to the AI, such as file contents, database schemas, or API documentation
• Prompts: Pre-defined prompt templates that servers can provide to help AI agents use their capabilities effectively
• Sampling: A mechanism that allows servers to request LLM completions from the client, enabling sophisticated multi-step workflows

Protocol Flow

The typical interaction flow between an MCP client and server follows these steps:

1. Client connects to server via stdio, HTTP, or WebSocket
2. Client sends initialize request with capabilities
3. Server responds with its capabilities (tools, resources, prompts)
4. Client discovers available tools via tools/list
5. User interaction triggers tool invocation
6. Client sends tools/call request with arguments
7. Server executes the tool and returns results
8. Client incorporates results into AI context
9. Cycle repeats as needed for multi-step tasks

Security Model

MCP implements multiple layers of security to ensure safe operation in production environments:

• Capability Negotiation: Clients and servers explicitly declare their capabilities, ensuring both parties understand the interaction scope
• Human-in-the-Loop: Tool invocations can require user confirmation, preventing AI agents from taking unauthorized actions
• Sandboxing: Servers can be run in isolated environments with restricted permissions and resource limits
• Authentication: The protocol supports standard authentication mechanisms including OAuth, API keys, and certificates

The Linux Foundation: Trusted Stewardship for Critical Infrastructure

The choice of the Linux Foundation as the home for the Agentic AI Foundation was deliberate. The Linux Foundation has a proven track record of governing critical open source infrastructure, including Linux itself, Kubernetes, Node.js, and countless other foundational technologies.

Under Linux Foundation governance, MCP benefits from established processes for community contribution, technical decision-making, trademark protection, and legal support. The foundation's vendor-neutral stance ensures that no single company can dominate the protocol's direction, fostering trust among competitors who all depend on the standard.

Governance Structure

The Agentic AI Foundation operates with a structured governance model designed to balance rapid innovation with stability:

• Technical Steering Committee: Oversees technical direction with representatives from co-founders and major contributors
• Governing Board: Handles strategic decisions, membership, and resource allocation
• Working Groups: Focused teams addressing specific areas like security, enterprise features, and SDK development
• Community Contributors: Open participation for anyone who wants to contribute code, documentation, or ideas

Implications for the AI Industry

The establishment of the Agentic AI Foundation and the transition of MCP to open governance has far-reaching implications for the AI industry, developers, enterprises, and end users.

For AI Platform Providers

AI platform providers now have a clear standard to build upon. Rather than competing on integration capabilities, they can focus on their core strengths knowing that users can easily connect their AI to any MCP-compatible tool. This commoditization of the integration layer encourages competition on model quality and user experience.

For Developers

Developers building AI-powered applications benefit from a dramatically simplified integration process. Building a single MCP server makes a tool accessible to every MCP-compatible AI assistant, multiplying the potential user base with minimal additional effort. The growing ecosystem of existing MCP servers also means developers can quickly assemble powerful AI applications from pre-built components.

For Enterprises

Enterprise IT departments can adopt MCP with confidence, knowing it's backed by industry leaders and governed by a neutral foundation. The protocol's security model and extensibility make it suitable for connecting AI agents to sensitive internal systems while maintaining appropriate controls and audit trails.

For End Users

End users experience more capable AI assistants that can seamlessly integrate with the tools and services they already use. The standardization ensures consistent behavior across different AI platforms, reducing the learning curve when switching between assistants or using multiple AI tools.

Getting Started with MCP: A Developer's Guide

For developers eager to start building with MCP, the protocol offers straightforward pathways to both consuming existing servers and creating new ones.

Using Existing MCP Servers

The fastest way to leverage MCP is through existing servers. The community has built servers for popular services including:

• Databases: PostgreSQL, MySQL, MongoDB, Redis, and SQLite servers for direct database interaction
• File Systems: Servers for browsing, reading, writing, and searching local and remote file systems
• Developer Tools: Git, GitHub, GitLab, Jira, and other development platform integrations
• Communication: Slack, Discord, email, and other messaging platform servers
• Web: Browsers, web scraping, and search engine servers for internet access

Building Your First MCP Server

from mcp import Server, Tool
import mcp.types as types

# Create a new MCP server
server = Server("example-server")

# Define a simple tool
@server.tool()
async def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # In production, you'd call a weather API
    return f"The weather in {city} is sunny and 72°F"

# List available tools
@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="get_weather",
            description="Get the current weather for a city",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"]
            }
        )
    ]

# Run the server
if __name__ == "__main__":
    server.run()

The MCP SDKs handle all protocol complexity, allowing developers to focus on implementing business logic. Comprehensive documentation, tutorials, and examples are available through the official MCP GitHub organization.

The Road Ahead: Future of the Agentic AI Foundation

With the foundation established and governance in place, the focus now turns to expanding MCP's capabilities and ecosystem. Several major initiatives are already underway:

Upcoming Features

• MCP 2.0: The next major version will introduce enhanced streaming capabilities, better handling of long-running operations, and improved multimodal support
• Enterprise Extensions: Features for audit logging, access control, compliance reporting, and enterprise identity integration
• Server Discovery: A registry system for discovering and connecting to MCP servers dynamically
• Agent-to-Agent Communication: Extensions for AI agents to communicate and collaborate with each other through MCP

Conclusion: A Defining Moment for AI Interoperability

The donation of the Model Context Protocol to the Agentic AI Foundation represents a defining moment in the evolution of artificial intelligence. By bringing together competitors under shared governance, the AI industry has acknowledged that certain infrastructure must be developed collaboratively for the benefit of all participants.

With 97 million monthly SDK downloads, over 10,000 active servers, and support from every major AI platform, MCP has already proven its value as a universal standard. The transition to Linux Foundation governance ensures that this critical infrastructure will continue to evolve in response to community needs rather than any single company's priorities.

For developers, the message is clear: MCP is the protocol to learn for AI integration work. The skills and servers built today will remain relevant as the ecosystem continues to grow under stable, open governance.

For enterprises, the establishment of the Agentic AI Foundation provides confidence that MCP investments are protected by vendor-neutral oversight. The protocol's adoption by competitors like OpenAI, Google, and Microsoft alongside its creator Anthropic demonstrates unprecedented industry alignment.

For the AI industry as a whole, this moment signals maturation. Just as the web flourished on open standards like HTTP and HTML, the age of AI agents will be built on open protocols like MCP. The Agentic AI Foundation exists to ensure these protocols remain open, evolving, and accessible to all.