Model Context Protocol · AI Agents · 2026
MCP stopped being a local toy. It's the protocol that connects agents to the real world — and Uber already runs 1,500 of them in production.
Not a keynote, it's production
And they're not alone: Anthropic donated MCP to the Agentic AI Foundation, under the Linux Foundation, where direct competitors — Anthropic, OpenAI, Google, Microsoft, AWS, Cloudflare, Bloomberg and Block — push the same standard. That's rare in AI. It happens because they all realized the same thing: without a connectivity standard, agents don't reach production.
5,000
Engineers, 90% using agents
10,000+
Internal services
1,500
Active agents per month
60,000
Executions per week
An open protocol Anthropic created in late 2024. Instead of each agent learning to talk to each tool differently, there's a standard.
MCP CLIENT MCP SERVER TOOLS
Claude Code, ←────→ exposes tools ←────→ Slack, GitHub,
Cursor, ChatGPT DB, Drive, FigmaThe official libraries to build MCP servers already exceed 110 million monthly downloads — and reached that figure in roughly half the time it took React.
You open Claude Code, connect a server running on your machine and use it alone. Fine for an individual dev. But with authentication, governance and 5,000 people at once? That's where the real story starts.
David Soria Parra — co-creator of MCP and lead maintainer of the protocol at Anthropic — laid it out across three years.
2024 · The year of demos
MCP is born in late 2024. Proofs of concept, toy integrations, lots of potential with no production behind it.
2025 · The year of coding agents
Agents that run in your terminal, write code and call the compiler. Controlled sandbox, everything on your machine, easy to verify.
2026 · The year of general agents
Agents doing real office work: financial analysis, marketing, operations, support. They need something new: massive connectivity with authentication, permissions and governance.
If someone tells you there's ONE solution for everything, they're wrong. They're three tools in a toolbox — each agent picks the ones it needs.
Domain knowledge
Simple files that tell the agent how to do something. Reusable. Everyone uses this one, always.
Remote connectivity
When you need authorization, governance, platform independence or to connect to enterprise services. It's for when you DON'T have a sandbox: production.
Local execution
When you have a sandbox, a terminal and tools already in pre-training: git, gh, gcloud. For agents that run on your machine.
| Agent | Skills | MCP | CLI |
|---|---|---|---|
| Coding agent (Claude Code, Cursor, Codex) | ✅ | ✅ | ✅ |
| Agent with Anthropic API in production | ✅ | ✅ | Depends |
| ADK agent on Cloud Run (ours) | ✅ | ✅ | Generally no |
| Uber (1,500 agents) | ✅ | ✅ | Coding agents only |
They all use Skills and MCP. The difference is CLI: only the ones with a terminal and a sandbox. MCP doesn't belong to Claude Code — it's an open protocol any agent can use: ADK, LangChain, the Anthropic API, whatever.
Google Cloud's framework so you don't get confused. They're not competitors: different tools for different problems, and in a real system you use several at once.
| What do you need? | Tool |
|---|---|
| Info from a content library? | RAG |
| Standardized access to data? | MCP (lookup) |
| The agent does something in the real world? | MCP (action) |
| Teamwork inside your app? | Sub-agents |
| Agents from different organizations? | A2A |
The harness controls the agent, but it needs connectivity. MCP is the layer it was missing — Soria Parra himself uses the term "agent harness" in his keynote.
Everything around the model: restrictions, permissions, observability. What decides what the agent can do.
The standardized layer that connects the agent to real-world tools. The two pieces an agent needs to work in production.
What is the harness? I took it apart in another video. Watch Harness Engineering ›
Probably the clearest pattern of what MCP looks like at scale. Getting there wasn't free — they had three serious problems.
Each team built its own MCP integration, with no standard or central framework. Most of it wasn't reusable. Everyone solving the same thing separately.
With agents, the blast radius is higher than with humans. An agent with the wrong access breaks things far faster than a developer. They needed full visibility into who accesses what.
How does an agent find the right MCP server? Not just any — one that's reliable, performant and secure. A bad tool doesn't just fail: it degrades the whole agent.
The solution: Orchestrator + Gateway
ORCHESTRATOR → reads the 10,000 service files and uses an LLM
to generate the MCP tool descriptions
(each service's owners stay in control)
GATEWAY → single entry point. Every agent goes through it:
authorization · sensitive-data redaction ·
code scanning · guardrails · logging and tracingThe key was automation: forcing 5,000 engineers to hand-write MCP servers would kill the initiative. Generating the descriptions by reading the definitions that already existed is what made adoption work at scale.
Thousands of internal teams create productivity agents without writing code.
Where they build the complex agents: customer support, shopping assistant, service coordination.
95% of their engineers use them. An internal agent, "Minions", ships 1,800 code changes per week.
| Layer | What it does | Who decides |
|---|---|---|
| Scoping | Which tools are available to each agent | The system |
| Tool selection | Which specific tools this agent uses | The developer |
| Parameter overrides | Which parameters are fixed and untouchable | The developer |
The agent doesn't freely pick among all tools. Each layer removes a point of failure — the same principle as Agent Skills: you don't give it access to everything, you give it access to exactly what it needs. We showed it in February; Uber implemented it at enterprise scale.
He didn't just talk about the vision. He presented two concrete techniques already in use.
Today most MCP clients load every tool into the context upfront — then act surprised it's huge. The fix: give the model a tool to search for tools. "I need something for DNS" → the search returns the specific tool, loaded only when needed. If you use Claude Code, deferred tools are already this pattern. Uber has it on its roadmap as the "omni MCP tool".
Today, to use 5 tools the agent makes 5 roundtrips: call, wait, think, call, wait. Each with latency. The fix: give it an execution environment where it writes code that composes the 5 tools into a single call. In Soria Parra's words: "We're just not doing this enough yet."
Three big things landing in the spec that change how agents get built in production.
Stateless transport
The original transport used persistent connections — a problem for serverless like Cloud Run or Lambda that scale to zero. Streamable HTTP (one endpoint, stateless) has existed since March 2025; the spec gets formalized soon. It means native MCP servers on Cloud Run and Kubernetes, scaling to zero, with no idle connections.
Server discovery
Standardized URLs so agents discover MCP servers automatically. Something like robots.txt, but for agents: your agent lands on a site, asks "do you have an MCP server?" and finds it on its own.
Skills over MCP
The MCP server doesn't just hand you tools: it also sends the domain knowledge of how to use them. The server author updates the skills without depending on anything external. All distributed alongside the tools.
Who governs MCP
Since December 2025 it's under the Agentic AI Foundation, within the Linux Foundation. Co-founders: Anthropic, Block and OpenAI. Platinum members: AWS, Bloomberg, Cloudflare, Google and Microsoft. Anthropic, Google, OpenAI, Microsoft and Amazon sitting at the same table, defining how agents connect to the world.
ThoughtWorks put MCP in "Trial" on its Technology Radar — recommended for real projects. But with a warning: the direct API-to-MCP conversion went into "Avoid". REST is designed for humans; MCP requires design for agents. Design for agents, don't convert for agents.
Every era of computing had a protocol that defined how things connect.
HTTP → connected web pages
REST → connected applications
gRPC → connected microservices
MCP → connects AI agents to the real worldEach video was a piece of the puzzle. MCP is the one that was missing: connectivity.
The primary sources cited in the video.
David Soria Parra · Anthropic · April 2026
Co-creator of MCP. The 3 connectivity options, progressive discovery and programmatic tool calling. "2026 is the year of general agents."
Uber · MCP Dev Summit (AAIF) · 2026
Meghana Somasundara and Rush Tehrani present the MCP Gateway + Registry: 5,000 engineers, 10,000 services, 60,000 executions per week.
Google Cloud Tech · 2026
The simple framework for deciding what to use and when. They're not competitors: different tools for different problems.
ThoughtWorks · 2026
MCP in "Trial" (recommended for real projects). But the direct API-to-MCP conversion in "Avoid" — exactly Soria Parra's "cringe".
Martin Fowler · 2026
The context surrounding the model and how tools — MCP included — shape what an agent can actually do.
Each piece of the system, in its own video. MCP is the connectivity layer that ties them together.
The framework that controls the agent. MCP is the connectivity layer the harness was missing.
How the agent's work repeats over time. The loop uses the tools MCP connects.
Skills as domain knowledge: the first of the 3 connectivity options. You don't give it everything, you give it what it needs.
The skill factory. With skills over MCP, those skills get distributed alongside the tools.
7 agents in production that delegate tasks. The infrastructure where all this runs.
Workspace profiling and governance: the code decides permissions, not the model. Uber does it at scale with its gateway.
The essentials about Model Context Protocol.
It's an open protocol created by Anthropic in late 2024 that standardizes how AI agents connect to external tools. Instead of each agent learning to talk to each tool differently, there's a common protocol: an MCP server exposes tools and an MCP client (Claude Code, Cursor, ChatGPT) connects and uses them.
It's a service that exposes tools through the MCP protocol. Today there are MCP servers for Slack, GitHub, databases, Google Drive, Figma or Blender. An agent connects to the server and uses those tools without knowing the internal details. The official libraries to build them already exceed 110 million monthly downloads.
With a client-server model. The MCP server exposes tools; the client connects and the agent calls them when needed. Locally you use it alone. In production you add authentication, governance and a centralized gateway — like the one Uber built — that controls which agent accesses which tool.
No. Since December 2025 MCP is under the Agentic AI Foundation, within the Linux Foundation. Co-founders: Anthropic, OpenAI and Block; platinum members: AWS, Bloomberg, Cloudflare, Google and Microsoft. It's an open protocol any agent can use — ADK, LangChain, the Anthropic API — not just Claude Code.
They don't compete, they solve different problems. RAG: pull info from a content library. MCP: standardized access to data or executing an action in the real world. Sub-agents: teamwork inside your app. A2A: agents from different organizations talking to each other. In a real system you use several at once.
Yes, and already at scale. Uber runs 1,500 active agents and 60,000 executions per week over MCP, connected to more than 10,000 internal services via a centralized MCP Gateway with authorization, automatic redaction of sensitive data and guardrails. It's not a pilot: it's how they work.
No. Soria Parra called it "cringe" and ThoughtWorks put the direct API-to-MCP conversion in "Avoid". REST is designed for humans; MCP requires design built for agents: fewer tools, with clear descriptions. The rule is design for agents, don't convert for agents.
Community
MCP servers, gateways and agents connected to real tools — the Uber-case architecture applied to your stack, with repos and hands-on examples. Free community access; the full courses are in the Premium tier.
Join Agentic Engineers →YouTube channel
@NicolasNeiraGarcia
ADK · A2A · Claude Code · Automation · Infrastructure