The ecosystem, and where to go next
Seventeen lessons ago MCP was a diagram; now it is a wire you can read, two sides you can build, a threat model you can argue with, and — as of last lesson — a running composition. This last lesson zooms out — where the protocol sits in the 2026 landscape, how it composes with the frameworks you may already use, and which door to take from here.
The protocol grew up fast
Since the November 2024 release, MCP has done the two things that decide whether a standard survives: every major model vendor and host adopted it, and the spec kept moving without breaking its old sessions — streamable HTTP replacing SSE, elicitation arriving mid-2025, and the version negotiation you watched absorb change in lesson 10, when one unmodified server agreed to 2025-06-18 with one client and 2025-11-25 with another. That is what "evolves without flag days" looks like on the wire. An official registry now anchors discovery, with the audit-and-pin discipline from lesson 14 still yours to apply — a registry is a phone book, not a vouching service.
MCP inside the agent frameworks
The agent ecosystems converged on MCP as their capability layer, which changes what "framework choice" means. LangGraph loads MCP servers through adapter libraries and hands the tools to its graph nodes; LlamaIndex wraps them for its agents; CrewAI and PydanticAI take server connections near-natively (PydanticAI most completely, sampling included). Coverage details shift release to release — check current docs, not this paragraph — but the architectural point is stable: the framework is the host. Its planner is the model loop from lesson 10 writ large; its tool registry is discovery; your Paper Trail server plugs into any of them unchanged, because capability stopped being a framework feature the day it became a protocol. Choose frameworks for orchestration ergonomics; capabilities are portable now.
MCP and A2A, without the confusion
You will meet the Agent2Agent protocol (A2A) in the same conversations. The tidy separation: MCP connects an application to capabilities — tools, data, workflows, the vertical axis. A2A connects agents to other agents — discovery, task delegation, long-running exchanges between autonomous peers, the horizontal axis. A support agent might use MCP to reach the order database and A2A to hand a case to a billing agent — complementary layers, not competitors, whatever the discourse of the week suggests.
The capstone, continued
Lesson 17 left you with a running two-server composition and a governance checklist. The version worth another weekend: swap the filesystem server for a web-search server from the registry, put lesson 16's OAuth in front of a hosted Paper Trail, and give the notes tools a real vector store — at which point you have built, from parts you understand down to the frames, the "research assistant" that a dozen products currently sell. The difference between yours and theirs is that you can read yours on the wire.
Three doors out
Deeper into agents: the loop around your client — planning, memory, recovery, multi-agent handoffs — is AI Agents in Production; you now hold its capability layer, and its MCP material will read as review. Deeper into retrieval: if the capstone's notes tools interested you more than the wiring, Building RAG Systems is that discipline end to end — chunking, reranking, and the evaluation that separates working retrieval from demos. Deeper into one host done exceptionally well: Claude for Developers shows the platform view — MCP as one layer of a full development lifecycle, from the API to multi-agent systems.
The idea to keep
Strip the SDKs and one idea remains: capability became data. Not code linked into an application — a list, fetched fresh each session, described in prose a model can read, governed by a control triangle that says who may invoke what. Everything else followed: discovery replaced redeployment, description became interface (twice — craft and attack surface), negotiation replaced flag days, and integration effort went from M×N to M+N. Protocols outlive frameworks. This one is young, its spec will keep moving — and you can now read its wire, which means nothing it does next will be magic.
Try this: build the capstone, or — the smaller, sharper exercise — take one integration you personally maintain as bespoke glue and rewrite it as an MCP server with three tools, one resource, and one prompt. Then point two different hosts at it. The moment the second host works unchanged is the course's whole argument, running on your machine.