November 2024, Revisited: The Model Context Protocol and Why Context Plumbing Needed a Standard

This post is part of our Three-Year Retrospective series: thirty-six posts, one per month, looking back at what actually mattered in software engineering. This one covers November 2024.

On November 25, 2024, Anthropic open-sourced the Model Context Protocol, and the announcement made barely a ripple outside the AI engineering corner of the internet. There was no model release attached, no benchmark chart — just a specification, two SDKs (Python and TypeScript), and a handful of reference servers for things like GitHub, Slack, Postgres, and a headless browser. It turned out to be one of the most consequential releases of the entire year.

The problem: N models times M tools

By late 2024, everyone building AI applications had hit the same wall. Models are only as useful as the context you can get into them, and every integration — your database, your ticket tracker, your docs, your filesystem — was a bespoke connector written against one application's plugin API. OpenAI had its function-calling conventions and plugin experiments, every agent framework had its own tool abstraction, and none of it transferred. Connecting N AI applications to M data sources meant N×M integrations, each one custom glue code.

MCP's pitch was the USB-C analogy before anyone called it that: standardize the connector. Write a server for your internal wiki once, and any MCP-capable application can use it. The protocol borrowed a proven playbook — the Language Server Protocol had done exactly this for editor/language integrations a decade earlier — and applied it to model context.

The architecture: hosts, clients, servers

The design was deliberately boring, which we mean as high praise. An MCP host is the AI application — at launch, essentially Claude Desktop. The host runs one client per connection, and each client speaks JSON-RPC 2.0 to a server that exposes some capability. Servers offer three primitives: tools (model-invoked actions), resources (application-controlled data to read), and prompts (user-selectable templates).

The launch transport was stdio: the host spawns the server as a local subprocess and exchanges JSON-RPC over stdin and stdout. Crude, local-only — and a brilliant adoption hack. Anyone could write an MCP server in an afternoon, in any language that can read stdin, with no auth, no hosting, no infrastructure. A remote-oriented HTTP+SSE transport existed in the spec, but the stdio path is what made the ecosystem ignite: within weeks there were community servers for seemingly everything, quality wildly variable, energy unmistakable.

We started teaching MCP almost immediately, and the lecture wrote itself around one idea: this is an integration standard, not an AI feature. The interesting questions were classic systems questions — capability discovery, transport, trust boundaries, what happens when a tool description lies. Treating it that way aged much better than treating it as a chatbot accessory.

The honest November 2024 caveats

It's worth remembering what skepticism looked like at the time, because it was reasonable. MCP was a single-vendor standard with exactly one significant host application. Remote deployment was awkward. There was no authorization story to speak of. The obvious question — why would OpenAI or Google ever adopt Anthropic's protocol? — had no obvious answer in November 2024. Betting on MCP then meant betting that an open, well-designed standard with a working ecosystem could outrun corporate gravity.

Looking back from June 2026

That bet paid out about as completely as these bets ever do. The March 2025 spec revision replaced the clunky HTTP+SSE transport with streamable HTTP, fixing remote deployment, and added the auth foundations the enterprise needed. Then the dominoes: OpenAI adopted MCP across its products in spring 2025, Google and Microsoft followed, and by year's end MCP was simply the way tools and agents connect — the question "why would competitors adopt it?" answered itself when the ecosystem got too valuable to fork. The protocol's stewardship broadened accordingly. Few specs have gone from announcement to industry plumbing this fast. The afternoon-sized server remains the on-ramp; in today's official Python SDK, a complete one looks like this:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("demo")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

if __name__ == "__main__":
    mcp.run()  # stdio by default; streamable HTTP for remote hosts

If you're building or consuming MCP servers — and in 2026, most AI engineering teams are doing both — our Model Context Protocol for Developers course works through the full protocol hands-on: servers, clients, transports, auth, and the security model that the first wave of community servers learned the hard way.