GAUTAM MANAK

Posted on Apr 10 • Originally published at github.com

MCP Ecosystem — Deep Dive

#ai #machinelearning #technology #programming

Welcome back to AI & Tech Daily. Today we're diving deep into what might be the most important infrastructure development in the AI space since the transformer architecture itself: the Model Context Protocol (MCP) ecosystem.

If you've been wondering why suddenly every major enterprise platform—from NetSuite to Gainsight to Domo—is announcing "MCP support," you're not alone. What started as Anthropic's open standard in late 2024 has rapidly evolved into the foundational protocol for the agentic web. And in 2026, we're seeing MCP mature from a promising spec into a full-blown ecosystem with governance, security frameworks, and enterprise-grade adoption.

Let's unpack everything happening in the MCP world right now.

Company Overview

The MCP ecosystem isn't a single company—it's an open standard and movement led by Anthropic but rapidly expanding across the entire AI infrastructure landscape. However, understanding the key players and their roles is crucial:

Anthropic launched the Model Context Protocol (MCP) in November 2024 as an open standard for connecting AI assistants to external data and tools. The mission was simple but profound: solve the fragmentation problem where every AI integration required custom development. With MCP, Anthropic created a universal protocol that standardizes how AI models discover, authenticate, and interact with external tools.

The MCP specification repository currently has 7,765 GitHub stars and serves as the canonical reference for implementers. Meanwhile, the official MCP servers repository has amassed 83,360 stars, demonstrating enormous community engagement.

Key Ecosystem Players:

Anthropic: Protocol creator and maintainer, with Python SDK at 3,187 stars
Model Context Protocol Organization: The governing body for the spec
MCP Suite: A developer platform providing tools to build, scan, test, monitor, and optimize MCP servers
MCP Agents Hub: An open-source ecosystem for building and deploying MCP servers in enterprise environments
GitHub: Launched the GitHub MCP Registry in September 2025 as a curated directory of MCP servers

Funding & Scale: While Anthropic remains the primary backer with its $4+ billion in funding, the broader MCP ecosystem has attracted significant investment. Companies building on MCP—including Domo, Gainsight, NetSuite, and Snowflake—represent hundreds of billions in combined market cap. The ecosystem has grown from zero to over 50+ official MCP server implementations by March 2026, with countless community implementations.

Latest News & Announcements

The MCP ecosystem is moving fast, with major announcements rolling in weekly. Here's everything you need to know from the past few months:

Agentic AI Foundation Announces Global 2026 Events Program Anchored by AGNTCon + MCPCon North America and Europe — The foundation's flagship events will bring together companies and developers building infrastructure for the agentic era. AGNTCon + MCPCon Europe runs September 17-18 in Amsterdam, Netherlands, followed by AGNTCon + MCPCon North America on October 22-23 in San Jose, California. These events signal MCP's emergence as a first-class citizen in the AI infrastructure landscape. source
Gainsight Opens Its Platform with MCP, Bringing Customer Retention Into the Agentic Era — Customer success and revenue teams can now build agentic retention workflows on Gainsight's customer intelligence using AI tools like Claude and ChatGPT. The integration unifies data from Gainsight CS and Staircase AI, enabling teams to query customer data in natural language, build custom workflows without engineering resources, and power autonomous, multi-step agent workflows across revenue organizations. source
NetSuite Upgrades Its MCP Support to Help Connect AI Assistants to Data and Processes — Oracle NetSuite this week launched enhanced MCP tools that provide pre-configured guidance, structure, and controls for connecting external AI assistants like ChatGPT and Claude. The new offerings include an AI Connector Service companion with finance-specific prompt templates, pre-configured roles for agents (CFO, Controller, AP/AR/Treasury analysts), and MCP Apps with structured interfaces like Report Picker and Record Picker. The upgrade addresses the security concerns of earlier implementations that lacked built-in guardrails. source
Domo Launches AI Agent Builder and MCP Server to Connect Enterprise Data to the AI Ecosystem — Unveiled at Domopalooza, Domo's new AI orchestration framework enables companies to orchestrate AI agents and enterprise data across workflows to power the next generation of intelligent enterprises. The announcement includes a new AI agent builder, MCP server, and tools designed to better orchestrate AI agents and enterprise data across business operations. source
QCon London 2026: Morgan Stanley Rethinks Its API Program for the MCP Era — At a major developer conference, Morgan Stanley discussed rethinking its API strategy for the MCP era, suggesting that traditional REST APIs are being reconsidered in light of agentic AI capabilities. The talk highlighted how financial institutions are adapting their infrastructure to support MCP-based agent interactions. source
Netzilo AI Edge Redefines Enterprise Control with Shadow AI Visibility, MCP Tool Governance, and AI Detection & Response — As enterprises adopt autonomous AI agents like Claude Cowork, security teams face new blind spots from unmanaged AI activity on endpoints. Netzilo's platform addresses this with MCP tool governance capabilities, giving organizations visibility and control over shadow AI usage. source
MCP, A2A, NLWeb, And AGENTS.md: The Standards Powering The Agentic Web — A comprehensive analysis of the four protocols becoming the foundation of the next phase of the web. The article positions MCP alongside Agent-to-Agent (A2A), Natural Language Web (NLWeb), and AGENTS.md as the shared standards that will power agentic applications, emphasizing that the web's future depends on these interoperability protocols. source
Operant AI Expands Gatekeeper Platform with MCP Gateway for AI Runtime Security — Operant AI launched its AI Infrastructure Ecosystem Partnership Program and expanded its Gatekeeper platform with an MCP Gateway for comprehensive AI runtime security. The platform provides real-time security for AI, agents, and MCP deployments, addressing the security concerns that emerged as MCP adoption accelerated. source
Teradata Joins Snowflake, Databricks in Expanding MCP Ecosystem — Teradata released its first Model Context Protocol server with a Community Edition supporting agentic workflows and generative AI use cases. A commercial-grade version is in development, further solidifying the data warehouse platform's commitment to the MCP standard alongside competitors Snowflake and Databricks. source
GitHub Introduces Registry for Finding MCP Servers — GitHub launched the GitHub MCP Registry, a curated registry of Model Context Protocol servers with repositories on GitHub. The registry, launched September 16, 2025, provides developers with a centralized place to discover and evaluate MCP servers, accelerating adoption and reducing integration friction. source

Product & Technology Deep Dive

Let's get technical about what MCP actually is and how it works.

The Core Problem MCP Solves

Before MCP, every AI integration was custom-built. If you wanted Claude to query a database, ChatGPT to access a CRM, or an AI agent to trigger an API call, you had to write custom code for each combination. This created massive duplication, security vulnerabilities, and a fragmented ecosystem where tools couldn't easily work together across different AI platforms.

MCP Architecture

The Model Context Protocol is an open standard that defines:

Tool Discovery: A standardized way for AI assistants to discover available tools and their capabilities
Authentication & Authorization: Built-in mechanisms for secure access control
Request/Response Protocol: JSON-based messaging for tool invocation
Capability Negotiation: Dynamic determination of what tools can do based on user permissions

At its core, MCP operates on a client-server model:

MCP Clients: AI assistants and agents (Claude Desktop, Cursor, Windsurf, custom applications)
MCP Servers: Implementations that expose tools and data sources (database connectors, API wrappers, file system access)
MCP Registry: Discovery mechanism for finding available servers

Key Components

1. MCP Specification
The formal spec defines the protocol's behavior, including message formats, error handling, authentication flows, and capability descriptors. It's transport-agnostic, meaning MCP can run over stdio, WebSocket, HTTP, or custom transports.

2. MCP Servers
Servers expose tools through a standardized interface. Each tool has:

A unique name and description
Input schema (JSON Schema)
Output schema
Metadata about capabilities, permissions required, rate limits

3. MCP Clients
Clients implement the protocol to:

Connect to servers
Authenticate users
Discover available tools
Invoke tools with proper authorization
Handle responses and errors

4. MCP Registry
The registry (like GitHub's MCP Registry) serves as a central directory where developers can discover, evaluate, and install MCP servers. This is analogous to npm for JavaScript packages or PyPI for Python.

The Two-Tier Ecosystem

By March 2026, the MCP ecosystem divided into two distinct tiers:

Tier 1: Official/Enterprise MCP Servers

50+ official implementations
Maintained by platform vendors (NetSuite, Domo, Gainsight, Snowflake)
Enterprise-grade security and support
Regular updates and compliance certifications

Tier 2: Community MCP Servers

Hundreds of community implementations
Hosted on GitHub and community registries
Cover niche use cases and experimental features
Varying levels of maintenance and security

Security & Governance

A major evolution in 2026 has been the maturation of MCP security frameworks:

SAFE-MCP: A comprehensive security framework from the safe-agentic-framework project for documenting and mitigating threats in the AI Agent ecosystem
MCP Gateway: Operant AI's runtime security platform that monitors and filters MCP tool calls
Shadow AI Detection: Platforms like Netzilo provide visibility into unauthorized MCP tool usage
Enterprise Guardrails: NetSuite's enhanced MCP implementation includes pre-configured role-based access controls and prompt templates

GitHub & Open Source

The open-source nature of MCP has been critical to its rapid adoption. Let's look at the key repositories and their metrics:

Core Specification

MCP Spec — ⭐7,765 stars
- The canonical specification and documentation
- Latest version: 2025-11-25
- Contains protocol definitions, examples, and implementation guidelines

Official Implementations

MCP Servers — ⭐83,360 stars
- Official collection of MCP server implementations
- Latest: 2026.1.26
- Includes servers for filesystem, git, databases, and common APIs
Anthropic SDK — ⭐3,187 stars
- Python SDK with MCP client support
- Latest: v0.93.0
- Official client implementation for Anthropic's models

Community Ecosystem

Agent-MCP — Framework for creating multi-agent systems using MCP
- Enables coordinated AI collaboration through MCP
- Functions as both an MCP server and client
mcp-agent — Build effective agents using MCP and simple workflow patterns
- Streamlined approach to building AI agents
- Leverages MCP server capabilities
MCP Agents Hub — Open-source ecosystem for enterprise MCP deployment
- Central hub for discovering and deploying MCP servers
- Enterprise-focused features and tooling
agent-mcp-lab — Empowering global developers with MCP agent capabilities
- Unified framework for connecting AI agents
- Multimodal capabilities support
safe-mcp — Security framework for AI Agent ecosystem
- Threat documentation and mitigation strategies
- Security best practices for MCP implementations

Frameworks with MCP Integration

Many major AI frameworks now include MCP support:

LangChain — ⭐133,005 stars — MCP integration for tool calling
LangGraph — ⭐28,855 stars — Agent graphs with MCP tools
CrewAI — ⭐48,489 stars — Multi-agent orchestration with MCP
Phidata/Agno — ⭐39,312 stars — Agentic software platform with MCP
OpenAI Agents SDK — ⭐20,678 stars — Multi-agent workflows with MCP
Microsoft AutoGen — ⭐56,904 stars — Agentic AI framework with MCP support
Composio — ⭐27,702 stars — 1000+ toolkits with MCP integration
LiteLLM — ⭐42,783 stars — AI Gateway with MCP support
Pydantic AI — ⭐16,221 stars — AI Agent Framework, the Pydantic way

Registry & Discovery

GitHub MCP Registry — Official curated registry (launched September 2025)
Awesome MCP Servers — Community-maintained directory of useful MCP servers
MCP Gateway Registry — AI Registry Tools for discovering MCP tools

Getting Started — Code Examples

Let's get hands-on with MCP. Here are three practical examples showing how to implement and use MCP servers.

Example 1: Creating a Simple MCP Server (Python)

This example shows how to create a basic MCP server that exposes a simple calculator tool:

from mcp.server import Server
from mcp.types import Tool, TextContent
import json

# Initialize the MCP server
app = Server("calculator-server")

# Define a simple calculator tool
@app.tool(
    name="calculate",
    description="Perform basic arithmetic operations",
    input_schema={
        "type": "object",
        "properties": {
            "operation": {
                "type": "string",
                "enum": ["add", "subtract", "multiply", "divide"],
                "description": "The operation to perform"
            },
            "a": {
                "type": "number",
                "description": "First number"
            },
            "b": {
                "type": "number", 
                "description": "Second number"
            }
        },
        "required": ["operation", "a", "b"]
    }
)
async def calculate(operation: str, a: float, b: float) -> list[TextContent]:
    """Perform arithmetic calculation."""
    operations = {
        "add": a + b,
        "subtract": a - b,
        "multiply": a * b,
        "divide": a / b if b != 0 else None
    }

    result = operations.get(operation)
    if result is None:
        return [TextContent(
            type="text",
            text=f"Error: Cannot divide by zero"
        )]

    return [TextContent(
        type="text",
        text=f"Result: {a} {operation} {b} = {result}"
    )]

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

Example 2: Connecting an MCP Client (TypeScript)

This example shows how to create an MCP client that connects to servers and uses their tools:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

async function main() {
  // Create the MCP client
  const client = new Client({
    name: "my-agent",
    version: "1.0.0"
  }, {
    capabilities: {}
  });

  // Connect to an MCP server via stdio
  const transport = new StdioClientTransport({
    command: "python",
    args: ["calculator_server.py"]
  });

  await client.connect(transport);

  // List available tools from the server
  const tools = await client.listTools();
  console.log("Available tools:", tools.tools.map(t => t.name));

  // Call a tool
  const result = await client.callTool({
    name: "calculate",
    arguments: {
      operation: "multiply",
      a: 7,
      b: 6
    }
  });

  console.log("Result:", result.content[0].text);

  // Disconnect
  await client.close();
}

main().catch(console.error);

Example 3: Building an MCP Server with Database Access

This more advanced example shows an MCP server that connects to a database and exposes query capabilities:

from mcp.server import Server
from mcp.types import Tool, TextContent
import sqlite3
import json

app = Server("database-server")

# Database connection
def get_db_connection():
    conn = sqlite3.connect('company_data.db')
    conn.row_factory = sqlite3.Row
    return conn

# Tool for querying customer data
@app.tool(
    name="query_customers",
    description="Query customer data from the database",
    input_schema={
        "type": "object",
        "properties": {
            "limit": {
                "type": "integer",
                "description": "Maximum number of results",
                "default": 10
            },
            "min_revenue": {
                "type": "number",
                "description": "Filter by minimum annual revenue"
            },
            "industry": {
                "type": "string",
                "description": "Filter by industry"
            }
        }
    }
)
async def query_customers(
    limit: int = 10,
    min_revenue: float = None,
    industry: str = None
) -> list[TextContent]:
    """Query customer database with optional filters."""
    conn = get_db_connection()
    cursor = conn.cursor()

    query = "SELECT * FROM customers WHERE 1=1"
    params = []

    if min_revenue:
        query += " AND annual_revenue >= ?"
        params.append(min_revenue)

    if industry:
        query += " AND industry = ?"
        params.append(industry)

    query += " LIMIT ?"
    params.append(limit)

    cursor.execute(query, params)
    results = cursor.fetchall()

    conn.close()

    # Format results as JSON
    formatted = [dict(row) for row in results]

    return [TextContent(
        type="text",
        text=json.dumps(formatted, indent=2, default=str)
    )]

# Tool for getting customer health score
@app.tool(
    name="get_customer_health",
    description="Get health score and metrics for a specific customer",
    input_schema={
        "type": "object",
        "properties": {
            "customer_id": {
                "type": "string",
                "description": "Customer ID"
            }
        },
        "required": ["customer_id"]
    }
)
async def get_customer_health(customer_id: str) -> list[TextContent]:
    """Retrieve health metrics for a customer."""
    conn = get_db_connection()
    cursor = conn.cursor()

    cursor.execute("""
        SELECT 
            c.customer_id,
            c.company_name,
            c.health_score,
            c.nrr_score,
            c.product_usage_score,
            c.support_ticket_count,
            c.last_login_date
        FROM customers c
        WHERE c.customer_id = ?
    """, (customer_id,))

    result = cursor.fetchone()
    conn.close()

    if not result:
        return [TextContent(
            type="text",
            text=f"Customer {customer_id} not found"
        )]

    return [TextContent(
        type="text",
        text=json.dumps(dict(result), indent=2, default=str)
    )]

if __name__ == "__main__":
    import asyncio
    asyncio.run(app.run())

Market Position & Competition

The MCP ecosystem has rapidly established itself as the de facto standard for AI tool integration, but it faces competition and challenges. Let's analyze the landscape.

Competitive Landscape

Protocol/Platform	Origin	GitHub Stars	Focus	Strengths	Weaknesses
MCP	Anthropic (2024)	7,765 (spec)	AI tool integration	Open standard, broad adoption, enterprise support	Still evolving security model
A2A (Agent-to-Agent)	Google	23,109	Agent-to-agent communication	Focus on agent orchestration	More specialized scope
Composio	Independent	27,702	Tool integration	1000+ toolkits, comprehensive	Proprietary components
OpenAI Function Calling	OpenAI	N/A (SDK feature)	Tool calling	Native to popular models	Vendor-locked to OpenAI
LangChain Tools	LangChain	133,005 (framework)	AI framework integration	Mature ecosystem	Framework-dependent

Market Position

Strengths:

First-mover advantage: Launched November 2024, MCP had a significant head start
Vendor neutrality: Unlike OpenAI's function calling, MCP works across Claude, ChatGPT, and custom models
Enterprise adoption: Major platforms (NetSuite, Domo, Gainsight, Snowflake, Teradata) have committed to MCP
Open source governance: Community-driven development with clear specification process
GitHub Registry integration: Seamless discovery and installation workflow

Weaknesses:

Security concerns: Early implementations lacked proper guardrails (addressed in 2026 upgrades)
Fragmentation risk: Multiple registries and implementations could create compatibility issues
Competition from A2A: Google's Agent-to-Agent protocol may compete for agentic communication use cases
Learning curve: Requires understanding of new protocol concepts for developers

Market Share Analysis

Based on the data available:

Enterprise Platform Integration: MCP leads with 8+ major enterprise platforms announcing support (NetSuite, Domo, Gainsight, Snowflake, Teradata, etc.)
Developer Adoption: MCP Servers repo at 83,360 stars significantly outpaces alternatives
Registry Ecosystem: GitHub MCP Registry launched September 2025 provides centralized discovery
Security Framework: SAFE-MCP and dedicated security platforms (Operant AI, Netzilo) addressing enterprise concerns

Pricing & Business Models

MCP itself is free and open source, but the ecosystem has developed several commercial models:

Enterprise MCP Servers: Vendors like NetSuite and Domo offer MCP access as part of their enterprise subscriptions
MCP Management Platforms: MCP Suite and similar tools offer paid tiers for monitoring and optimization
Security Platforms: Operant AI, Netzilo charge for MCP governance and security features
Managed MCP Hosting: Cloud providers offering managed MCP server deployments

Developer Impact

The rise of MCP represents a fundamental shift in how developers build AI-powered applications. Let's explore what this means for builders.

Who Should Use MCP?

Enterprise Developers building internal AI tools will find MCP invaluable. As NetSuite's customers demonstrated, connecting AI assistants to enterprise data with proper governance is dramatically simplified with MCP. The pre-configured roles, prompt templates, and guardrails mean you don't have to build security from scratch.

SaaS Product Teams should integrate MCP to make their platforms AI-accessible. Gainsight's example shows how opening a platform via MCP enables customers to build custom agentic workflows without engineering resources. This creates a competitive advantage and reduces customer support burden.

AI Agent Developers working with multi-agent systems will benefit from MCP's standardized tool discovery. Frameworks like Agent-MCP and mcp-agent demonstrate how MCP enables coordinated agent collaboration without custom integration code for each tool.

Independent Developers building AI applications can leverage the growing ecosystem of community MCP servers. Instead of writing custom integrations for databases, APIs, and services, developers can simply connect to existing MCP servers.

Key Benefits for Developers

Reduced Integration Time: What previously took days of custom API integration can now be accomplished in hours by connecting to an existing MCP server
Security by Design: Built-in authentication, authorization, and audit logging mean you don't have to implement these from scratch
Interoperability: Tools built with MCP work across different AI platforms (Claude, ChatGPT, custom models) without modification
Community Reusability: The GitHub MCP Registry and community servers mean you don't have to build everything yourself
Enterprise Readiness: Major platform support means your MCP integrations will work with enterprise systems out of the box

Real-World Impact

The impact is already visible in customer success stories:

Yoto (children's audio platform): CFO Ben Averis reports that connecting NetSuite data to Claude via MCP "massively shortened the time it takes to create reports in Excel and PowerPoint"—from 3-4 hours to minutes
Octopus Energy: The UK's largest energy supplier is bringing agentic AI to procure-to-pay processes using MCP, emphasizing an "intent first, not AI first" approach
PartsSource: CCO Brad Casemore notes that Gainsight MCP allows bringing "real-time customer insights directly into our AI workflows and take action instantly, without jumping between systems"

Developer Tooling

The ecosystem has matured to include:

MCP Suite: Five tools for building, scanning, testing, monitoring, and optimizing MCP servers
AI Registry Tools: Natural language search for discovering MCP tools and servers
IDE Integration: Support in Cursor, Windsurf, and other AI coding assistants
Testing Frameworks: Automated testing for MCP server implementations
Monitoring & Analytics: Production monitoring for MCP tool usage and performance

What's Next

Looking at the trajectory of the MCP ecosystem and recent announcements, here are my predictions for what's coming in 2026 and beyond.

Near-Term Predictions (2026 Q2-Q4)

1. MCPCon Events Will Accelerate Adoption
The AGNTCon + MCPCon events in Amsterdam (September) and San Jose (October) will serve as catalysts for enterprise adoption. Expect major announcements from Fortune 500 companies committing to MCP strategies.

2. Security Standards Will Formalize
The SAFE-MCP framework and security platforms like Operant AI will likely merge into formal security standards for the protocol. We'll see SOC 2, HIPAA, and GDPR compliance certifications for enterprise MCP implementations.

3. MCP 2.0 Specification
Given the rapid evolution and lessons learned from early deployments, expect an MCP 2.0 specification that addresses:

Advanced capability negotiation
Streaming responses for long-running operations
Improved error handling and recovery
Enhanced permission models

Medium-Term Predictions (2027)

4. MCP Becomes Default for AI Integrations
Just as REST became the default for web APIs, MCP will become the expected standard for AI tool integration. SaaS products without MCP support will be considered incomplete.

5. Agentic Workflows Go Mainstream
The combination of MCP, A2A, and improved agent frameworks will make multi-agent workflows standard in enterprise operations. We'll see "agentic process automation" emerge as a new category.

6. MCP Marketplaces Emerge
Beyond the GitHub Registry, we'll see commercial MCP marketplaces where enterprises can buy, sell, and discover certified MCP servers with SLAs and support guarantees.

Long-Term Vision (2028+)

7. The "Agentic Web" Materializes
As Search Engine Journal noted, MCP alongside A2A, NLWeb, and AGENTS.md will form the foundation of a new web paradigm where AI agents can discover, negotiate, and interact with services autonomously.

8. MCP Becomes Protocol-Layer Infrastructure
Like TCP/IP for networking, MCP will become invisible infrastructure that powers AI interactions without users or developers thinking about it explicitly.

Roadmap Hints from Recent News

Based on the announcements:

NetSuite: Plans to make MCP tools available to "any MCP-compliant agent or assistant," suggesting broader compatibility efforts
Gainsight: Focus on "autonomous, multi-step agent workflows across revenue organizations" indicates complex workflow capabilities
Domo: Emphasis on "orchestrating AI agents and enterprise data across workflows" points to deeper integration capabilities
Security Vendors: Continued focus on "shadow AI visibility" and "MCP tool governance" suggests security will remain a priority

Key Takeaways

MCP Has Won the AI Integration War: With 83,360+ stars on the servers repo, 7,765+ on the spec, and adoption by 8+ major enterprise platforms, MCP has established itself as the de facto standard for AI tool integration
Enterprise Adoption Is Accelerating: NetSuite, Gainsight, Domo, Snowflake, Teradata, and others are not just experimenting—they're building production-grade MCP integrations with security, governance, and enterprise features
Security Is Finally Getting Serious Attention: After early implementations lacked guardrails, 2026 has seen the emergence of SAFE-MCP, Operant AI's MCP Gateway, and Netzilo's shadow AI detection—addressing the security paradox that threatened wider adoption
The Ecosystem Is Maturing Beyond the Spec: With GitHub's MCP Registry, MCP Suite developer platform, and dedicated conferences (MCPCon), MCP has evolved from a protocol into a full ecosystem with tooling, community, and events
Developers Should Start Building with MCP Now: The combination of reduced integration time, built-in security, interoperability across AI platforms, and growing community resources makes MCP the clear choice for AI tool integration
Multi-Agent Workflows Are the Next Frontier: Tools like Agent-MCP, mcp-agent, and CrewAI's MCP integration show how the protocol enables coordinated agent collaboration—this is where the most value will be created in the coming years
The Agentic Web Is Emerging: MCP, alongside A2A, NLWeb, and AGENTS.md, represents the foundational infrastructure for a new web paradigm where AI agents can autonomously discover and interact with services—developers who understand these protocols will be positioned to build the next generation of applications