Model Context Protocol (MCP)¶

Type: Agent integration standard
Related: anthropic-mcp-model-context-protocol, a2a-protocol, agent-tool-calling, mcp-server-development

What Is MCP?¶

The Model Context Protocol (MCP) is an open standard — announced by Anthropic in November 2024 — for connecting AI applications to external systems. It provides a standardized protocol for AI agents to discover and use tools, access data sources, and invoke workflows.

Think of MCP as USB-C for AI applications: just as USB-C provides a universal port for connecting devices, MCP provides a universal protocol for connecting AI agents to external capabilities. Tool authors write once; the integration works across every MCP-compliant AI client.

MCP is distinct from proprietary tool-calling schemas (e.g., OpenAI's function-calling format). Because it is an open, vendor-neutral protocol, MCP servers built for Claude work equally well with Cursor, VS Code Copilot, ChatGPT, Codex, and any other MCP-compliant client.

Architecture¶

MCP follows a host → client → server topology:

┌─────────────────────────────────────────────────────┐
│  MCP Host (AI Application)                          │
│                                                     │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐             │
│  │ Client 1│  │ Client 2│  │ Client 3│             │
│  └────┬────┘  └────┬────┘  └────┬────┘             │
└───────┼───────────┼───────────┼────────────────────┘
        │           │           │
    ┌───┴───┐   ┌───┴───┐   ┌───┴───┐
    │Server A│   │Server B│   │Server C│
    │(local) │   │(local) │   │(remote)│
    └────────┘   └────────┘   └────────┘

Participant	Description
MCP Host	The AI application (Claude Desktop, Claude Code, VS Code, Cursor). Coordinates one or more MCP clients.
MCP Client	One per server connection. Maintains a dedicated session with its server, handles protocol negotiation.
MCP Server	Exposes tools, resources, and prompts. Runs locally (STDIO) or remotely (HTTP).

Primitives¶

MCP servers expose three core primitives:

Tools — Executable functions the agent can call (e.g., search_web, query_database, send_email)
Resources — Contextual data the agent can read (e.g., file contents, schema definitions, API responses)
Prompts — Reusable interaction templates (e.g., system prompts, few-shot examples)

Transport¶

Transport	Use Case	Authentication
STDIO	Local servers on same machine	None (filesystem-level)
Streamable HTTP	Remote servers	OAuth, bearer tokens, API keys

Why MCP Matters for Agent Stacks¶

The Problem MCP Solves¶

Before MCP, connecting an AI agent to external tools required proprietary, one-off integrations:

OpenAI's tool calling only works within the OpenAI ecosystem
Each new tool required custom integration code per AI provider
The tool ecosystem fragmented along provider lines

MCP breaks this lock-in. Because the protocol is open and vendor-neutral, the growing ecosystem of MCP servers works across every MCP-compliant client.

The Agent-Native Stack Pattern¶

MCP enables a specific architectural pattern that the Factory calls the agent-native stack: instead of building a monolithic application that calls an AI API, you build a system where the AI agent is the primary orchestrator, and it connects to specialized MCP servers for each capability it needs.

┌──────────────────────────────┐
│  Claude Code (MCP Host)      │
│  ┌────────┐  ┌────────┐    │
│  │Client 1│  │Client 2│  ...│
│  └────┬───┘  └────┬───┘    │
└───────┼───────────┼────────┘
    ┌───┴───┐   ┌───┴───┐
    │Server │   │Server │
    │ A     │   │ B     │
    └───────┘   └───────┘

Implications:
- The agent can dynamically discover and use new tools at runtime (no code deployment)
- Adding a new channel (e.g., LinkedIn) means running a new MCP server; no changes to the agent
- The agent's capabilities are bounded only by the MCP servers available to it
- Security and permissioning live at the server level, not hardcoded in the agent

MCP vs. Proprietary Tool Calling¶

Dimension	MCP	OpenAI Tool Calling
Standard	Open, vendor-neutral	Proprietary, OpenAI-specific
Ecosystem	One server works across all MCP clients	Each provider needs separate integration
Tool discovery	Dynamic (`tools/list`)	Static (defined in schema at startup)
Transport	STDIO + HTTP, remote-capable	API-only
Authentication	OAuth, API keys, bearer tokens	API key only
Adoption	Cross-platform: Anthropic, Microsoft, Cursor, OpenAI	OpenAI-only (at protocol level)

Factory Relevance: Cogny as MCP-First Agent Stack¶

The Factory's Cogny project embodies the MCP-first agent stack pattern:

Cogny uses Claude Code as the MCP host
Each marketing channel (email, social, SMS, etc.) is a separate MCP server
Claude Code connects to 13 MCP servers — one per channel — enabling it to orchestrate multi-channel campaigns
Adding a new channel requires only a new MCP server; the agent doesn't change

This is the agent-native pattern: the agent is the orchestrator, and specialized MCP servers handle domain-specific operations. The alternative — hardcoding channel integrations — produces a brittle, single-purpose system.

a2a-protocol — Agent-to-Agent protocol; complements MCP for multi-agent orchestration. MCP connects agents to tools; A2A connects agents to other agents.
agent-tool-calling — The general practice of enabling LLMs to invoke external functions. MCP is one (increasingly dominant) implementation.
mcp-server-development — The practice of building MCP servers to expose domain-specific tools and data to AI clients.
autonomous-builder — Cogny's parent concept; the agent-native approach to building autonomous marketing systems.

Ecosystem Status (2026)¶

MCP has achieved broad adoption across the AI tooling ecosystem:

AI Assistants: Claude (Desktop + Code), ChatGPT (OpenAI MCP integration), Gemini (Google)
IDEs: Cursor, VS Code (Copilot Chat MCP support), JetBrains (via plugins)
Infrastructure: GitHub MCP server, Sentry MCP server, Slack MCP server, Notion MCP server, PostgreSQL/SQLite servers, filesystem servers

The MCP SDK is available in: Python, TypeScript, Java, Kotlin, Swift, C#/.NET, Rust.

Reference servers: https://github.com/modelcontextprotocol/servers