# The Future of MCP

David Soria Parra

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/v3Fr2JR47KA-future-of-mcp) · [Video](https://www.youtube.com/watch?v=v3Fr2JR47KA)

## The Future of MCP Is a Full Connectivity Stack for Production Agents

David Soria Parra explains why production agents need complementary connectivity methods, progressive tool discovery, programmatic composition, richer MCP applications, and a more scalable protocol.

![Selected presentation frame from The Future of MCP — David Soria Parra, Anthropic at 33 seconds](https://ai.engineer/api/talk-essay-media/c782eea03453c084794be0fd7ea0994ca959f8c689fd4c82274342302ac63415)

The Future of MCP Is a Full Connectivity Stack for Production Agents

### From tool protocol to shared application infrastructure

[0:15](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=15s)

An **MCP application** allows a server to deliver an interface alongside tools. Rather than hard-coding that interface into a particular product, generating it on the client, or distributing it through a plug-in or SDK, the server provides something that compatible clients can understand and render. David Soria Parra identifies Claude, ChatGPT, VS Code, and Cursor as examples of environments in which such a server can work. [0:15](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=15s)

The important architectural ingredient is **shared semantics**: both client and server need to understand that an interface exists, how it should be presented, and how interaction should proceed. Combining an application with tools also creates two complementary modes of access: a person can use the interface directly, while a model can operate through the associated tools. [0:15](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=15s)

Soria Parra describes MCP as having evolved from a local-only specification with a few SDKs and basic tools into a protocol with remote operation, centralized authorization, elicitation, tasks, and experimental applications. He reports approximately **110 million monthly downloads**, attributing that reach not only to direct usage but also to dependencies across OpenAI's agents SDK, Google's ADK, LangChain, and other frameworks. Public examples include integrations with WhatsApp, Blender, Linear, Slack, and Notion, although he says most servers connect private company systems to agents behind closed doors. [1:34](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=94s) [2:46](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=166s)

![Selected presentation frame from The Future of MCP — David Soria Parra, Anthropic at 29 seconds](https://ai.engineer/api/talk-essay-media/0c3aabf62664447edb470497564586868ccf1d1b78325c3bfb7c06d47011610c)

From tool protocol to shared application infrastructure

- MCP applications let servers deliver interfaces that compatible clients can render across different products.
- Shared protocol semantics coordinate interface presentation while enabling humans to use applications and models to use tools.
- MCP expanded from local tools to remote operation, centralized authorization, elicitation, tasks, and experimental applications.
- Approximately 110 million monthly downloads reflect adoption across agent frameworks and integrations, including private enterprise systems.

### Production agents require multiple kinds of connectivity

[3:59](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=239s)

Coding agents benefit from unusually favorable operating conditions: they often work locally, can verify results with a compiler, and have a developer nearby to intervene when something breaks. Soria Parra argues that broader knowledge-work agents face a different problem. A financial analyst or marketing professional may need an agent that can connect several SaaS applications and a shared drive, making **connectivity** central to the product rather than incidental to it. [3:59](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=239s)

His proposed connectivity stack has three broad categories: **Skills** for reusable domain knowledge, **MCP** for protocol-level interoperability and richer semantics, and **CLIs or Computer Use** when those approaches fit the environment. No single method should be treated as a universal answer; the appropriate choice depends on the agent, available execution environment, and task. [5:06](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=306s) [17:03](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1023s)

CLIs are especially useful for local agents because they compose naturally in bash, expose capabilities a model can discover, and align with familiar tools such as GitHub and Git. Their strengths depend on assumptions that do not always hold, including access to a sandbox and code execution. MCP becomes more compelling when an application needs platform independence, interfaces for long-running work, resources, authorization, governance, policies, or richer features such as MCP applications and Skills over MCP. [6:02](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=362s)

![Selected presentation frame from The Future of MCP — David Soria Parra, Anthropic at 416 seconds](https://ai.engineer/api/talk-essay-media/8519033d0eba3b780c434c6b057b710cd78171ccaab4450d7206c5ed8f2e2399)

Production agents require multiple kinds of connectivity

- Knowledge-work agents need connectivity across SaaS applications and shared drives, unlike locally verifiable coding agents.
- Skills provide reusable domain knowledge; MCP, CLIs, and Computer Use address different connectivity requirements.
- CLIs compose naturally in bash when agents have sandbox access and a code execution environment.
- MCP supports richer semantics, platform independence, authorization, governance, resources, and long-running task interfaces.

### Make the client responsible for progressive discovery

[7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s)

Soria Parra argues that excessive context usage should not automatically be blamed on MCP itself. A protocol transfers information between systems; the **client or agent harness** decides how that information enters the model's context. Early implementations often loaded every available tool immediately, creating unnecessarily large context windows as the number of integrations grew. [7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s) [8:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=500s)

The proposed alternative is **Progressive Discovery**. Rather than placing every tool definition in context at startup, the client gives the model a mechanism such as **Tool Search** and loads individual tools only when they become relevant. This effectively replaces an always-present catalog with an on-demand discovery process driven by the model's current needs. [8:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=500s)

Soria Parra says this pattern is available in Anthropic's product and API, can also be used through competing APIs, and can be implemented directly by application builders. He describes an example showing a substantial reduction in tool-context usage after the pattern was introduced, but the transcript does not provide a numerical measurement. The broader lesson is that scalable connectivity depends on deliberate client design, not merely on attaching more servers. [7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s) [8:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=500s)

![Selected presentation frame from The Future of MCP — David Soria Parra, Anthropic at 483 seconds](https://ai.engineer/api/talk-essay-media/13f5ccc30b29d876a373daca12751bef590860acd105b78a8d1f87da62fbb1a2)

Make the client responsible for progressive discovery

- The agent harness, rather than the protocol, determines which available tools enter the model context.
- Progressive Discovery uses Tool Search to defer loading tool definitions until the model needs them.
- On-demand tool loading can be implemented in existing products, APIs, or custom agent applications.

Progressive Discovery
The client loads tool definitions only after the model identifies a need.
- Model needs a tool — A task creates a capability requirement.
- Tool Search — The model looks up relevant tools.
- Load on demand — The client loads the selected tool.
- Model needs a tool → Tool Search (triggers lookup)
- Tool Search → Load on demand (loads when needed)

### Compose tools through code and design servers for agents

[9:36](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=576s)

A second client-side pattern is **Programmatic tool calling**, also described as **Code Mode**. When a model calls one tool, reads its response, calls another, and repeats the cycle, inference becomes part of every orchestration step. Soria Parra argues that this adds latency and can be less effective than having the model write a script that coordinates the necessary operations directly. [9:36](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=576s)

One implementation provides an execution environment such as a **V8 Isolate**, **Monty**, or a Lua interpreter, allowing generated code to compose tools, filter results, and continue processing without repeatedly routing every intermediate decision through the model. MCP's **Structured Output** can describe return values and provide type information that makes composition easier. When that information is unavailable, Soria Parra suggests using a cheaper model to extract output into an expected structure. [10:33](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=633s)

These ideas also change how servers should be built. Soria Parra discourages mechanically converting REST endpoints one-for-one into MCP tools; instead, server authors should design capabilities around how an agent or person would actually accomplish a task. Programmatic execution can exist on the client or the server, with the Cloudflare MCP server offered as an example of providing an execution environment rather than only isolated tools. He associates this approach with lower token usage, reduced latency, and stronger composition, while also encouraging server authors to use applications, Skills, Task, and Elicitations where those semantics genuinely help. [11:45](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=705s) [12:40](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=760s)

![Selected presentation frame from The Future of MCP — David Soria Parra, Anthropic at 786 seconds](https://ai.engineer/api/talk-essay-media/5b6dd43fe25e346dc9eab52fcabc557c6dc553aa56edcc2c1721bf4f52da1cf2)

Compose tools through code and design servers for agents

- Programmatic tool calling replaces repeated model-mediated orchestration with generated scripts that compose tool operations.
- Execution environments such as V8 Isolate, Monty, or Lua can run generated code and filter intermediate results.
- MCP Structured Output supplies return-value type information; a cheaper model can extract structured results when unavailable.
- Design MCP servers around actual agent tasks rather than mapping REST endpoints directly into tools.

Programmatic tool composition
Generated code executes and composes tools using structured return information.
- Generate code — The model writes orchestration logic.
- Execute code — V8 Isolate, Monty, or Lua runs the script.
- Compose tools — The script coordinates tool operations.
- Structured Output — Return-value types guide composition.
- Filter results — Intermediate JSON is reduced before continuing.
- Generate code → Execute code (runs generated script)
- Execute code → Compose tools (executes orchestration)
- Structured Output → Compose tools (provides type information)
- Compose tools → Filter results (filters intermediate output)

### Strengthen transport, identity, discovery, and extensions

[7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s)

Soria Parra identifies several protocol-level limitations that still need work. He says the current HTTP streaming approach is difficult to scale for large hyperscalers and describes a Google-backed proposal for a **Stateless Transport Protocol** that would make MCP servers behave more like familiar stateless REST services deployable on Cloud Runs or Kubernetes. He also describes asynchronous tasks as an experimental foundation for **agent-to-agent communication**, noting that few clients currently support the capability and that broader client adoption remains necessary. [13:49](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=829s)

The SDK and enterprise roadmap includes **TypeScript SDK version 2** and **Python SDK version 2**, incorporating lessons from the previous year. Soria Parra specifically credits **FastMCP** as a stronger Python SDK experience than the one his team shipped. He also outlines **Cross App Access**, intended to let users authenticate through a company identity provider such as Google or Okta and then access MCP servers without repeatedly logging in. [14:52](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=892s)

A proposed **Server Discovery** mechanism would define how agents, browsers, and crawlers find MCP servers through well-known URLs instead of relying solely on ordinary website parsing. Extensions introduce an explicit compatibility tradeoff: not every client can support every capability, and web-rendered MCP applications are poorly suited to CLI interfaces. Another planned extension, **Skills over MCP**, would let server authors distribute and continuously update the domain knowledge needed to use complex servers. Soria Parra notes that rudimentary versions can already be approximated with a tool that loads Skills, even before shared protocol semantics are finalized. [14:52](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=892s) [16:05](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=965s) [17:03](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1023s)

The overall direction is therefore not to replace CLIs, Computer Use, or Skills with MCP, but to make these methods interoperable within a more capable agent stack. Soria Parra presents the protocol's evolution as an open-community effort that depends on continued feedback, while acknowledging that current agents, harnesses, client support, and protocol details still require substantial improvement. [7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s) [17:03](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1023s)

![Selected presentation frame from The Future of MCP — David Soria Parra, Anthropic at 852 seconds](https://ai.engineer/api/talk-essay-media/d798c45073806014bd43cf2ad488210f64712e9b73413cb1523e927bc1f56333)

Strengthen transport, identity, discovery, and extensions

- Stateless Transport Protocol targets scalable REST-like deployment; asynchronous tasks need broader client support for agent-to-agent communication.
- TypeScript SDK version 2 and Python SDK version 2 incorporate lessons from earlier SDK implementations.
- Cross App Access reuses company identity-provider authentication, while Server Discovery locates MCP servers through well-known URLs.
- Skills over MCP lets server authors distribute continuously updated domain knowledge; extension support depends on client capabilities.

## Key takeaways

- **MCP applications** can deliver a portable interface and model-accessible tools from the same server, provided clients and servers share the necessary semantics. [0:15](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=15s)
- Production-oriented agents need a **connectivity stack** that combines Skills, MCP, CLIs, and Computer Use according to the environment and task. [5:06](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=306s) [6:02](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=362s) [17:03](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1023s)
- **Progressive Discovery** reduces unnecessary context load by searching for and loading tools only when the model needs them. [7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s) [8:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=500s)
- **Programmatic tool calling** moves multi-step orchestration into executable code, while **Structured Output** supplies type information that supports composition. [9:36](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=576s) [10:33](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=633s)
- Agent-friendly MCP servers should expose meaningful workflows and rich protocol semantics rather than mechanically reproducing REST APIs endpoint by endpoint. [11:45](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=705s) [12:40](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=760s)
- The outlined roadmap addresses scalability, asynchronous tasks, improved SDKs, enterprise authentication, automatic server discovery, and **Skills over MCP**, while acknowledging uneven client support. [13:49](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=829s) [14:52](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=892s) [16:05](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=965s) [17:03](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1023s)

## Slides

### AI Engineer Europe

[0:00](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=0s) [AI Engineer Europe logo in white on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/8ff101b24c02f7e85087bb029657bc6eb7970e19474b26755f1442a0c085f7c6.webp)

AI Engineer
EUROPE

### Presenting Sponsor

[0:05](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=5s) [Presenting sponsor Google DeepMind on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/64dbbd38edf0b5a4413ca31c774c8fb0166787f0a3874001d145da8aa6240660.webp)

PRESENTING SPONSOR

Google DeepMind

### Platinum Sponsors

Braintrust, WorkOS, and OpenAI are platinum sponsors.

[0:10](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=10s) [Platinum sponsors Braintrust, WorkOS, and OpenAI on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/26485f11edab7fc7d855d387ac10786e076ee06388b604934661e0dbfed3b9db.webp)

PLATINUM SPONSORS

Braintrust
WorkOS
OpenAI

### Raspberry Pi Drawing Demo

Claude displays an Excalidraw drawing with a green Raspberry Pi board outline. The speaker describes it as an MCP application whose interface is served by an MCP server.

[0:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=20s) [Claude displays an Excalidraw Raspberry Pi heading above a green board outline.](https://assets.ai.engineer/sites/aiecode2025/sha256/f5dbd920f8d9e65a1347a662e1a5d7f93259776ca491dadb70e35cf7e7ef9b5f.webp)

Raspberry Pi 5
~ a cute lil diagram ~

Interface text:
Claude  File  Edit  View  Developer  Window  Help
Thu Feb 5 07:26
FEBRUARY
M T W T F S S
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28
London
Expect light rain in the next hour
Now  60m
Chat  Cowork  Code
Cute Raspberry Pi 5 drawing in Excalidraw
Excalidraw create_view
Reply...
Opus 4.6
Claude is AI and can make mistakes. Please double-check responses.

### Raspberry Pi Drawing: Later Demo State

Claude displays an Excalidraw view of a Raspberry Pi board with a dark component across its top. The speaker says the interface is served by an MCP server and can run in multiple clients.

[0:42](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=42s) [A close-up of the green board drawing with a dark horizontal component near its top.](https://assets.ai.engineer/sites/aiecode2025/sha256/170b8a2203234939f8dc5add482a7c15c0705a5eb019d8ddd4691cb65c415222.webp)

Interface text:
Claude  File  Edit  View  Developer  Window  Help
Thu Feb 5 07:27

FEBRUARY
M T W T F S S
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28

London
6°
Drizzle
H:9° L:6°

Chat  Cowork  Code
Cute Raspberry Pi 5 drawing in Excalidraw
Excalidraw create_view
Reply...
Opus 4.6
Claude is AI and can make mistakes. Please double-check responses.

### An interface delivered through a protocol

An MCP server can deliver an application's interface to a client. The protocol gives both sides shared semantics to recognize and render the UI.

[0:47](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=47s) [Dark slide stating that an agent ships its own interface through a protocol.](https://assets.ai.engineer/sites/aiecode2025/sha256/0deec3d2bd405def4707da437fe6fc7c8d6cb255bb4f326f02840a850fd58c9e.webp)

What you just saw

A agent shipping its own interface —
through a protocol.

### How we got here

A year earlier, MCP was a local spec with little beyond tools. David Soria Parra recalls a few SDKs and the community building servers and an ecosystem afterward.

[1:36](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=96s) [Slide says that a year earlier MCP was a local specification with little more than tools; the speaker stands beside it.](https://assets.ai.engineer/sites/aiecode2025/sha256/6c911e860bd5c8de7c34be2acbc81dd63f57a113f70b30354dcdb85958e3dc29.webp)

How we got here

A year ago this was a spec doc, local only, with little more than just tools.

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

### Using the right tool

Skills package domain knowledge; MCP provides integration across boundaries; CLI and computer use access existing systems. Agents can combine them according to the job.

[5:27](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=327s) [A diagram compares skills, MCP, and CLI or computer use as complementary agent tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/09559f15e54a678724e41aea373eedfcdb7fb997afbfe42677adef548748f48e.webp)

The connectivity stack
Using the right tool

Skills
Domain knowledge captured as reusable instructions.

MCP
The integration protocol. Semantics, governance, and reach across boundaries.

CLI / Computer use
General access to existing systems. Discoverable, composable, Unix-style.

These compose. Agents in 2026 use all of them.

### Domain Knowledge

Skills capture capabilities and domain knowledge in simple files. They are mostly reusable, though they have platform dependencies and require a sandbox.

[5:45](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=345s) [The slide describes skills as capturing specific capabilities and being mostly reusable.](https://assets.ai.engineer/sites/aiecode2025/sha256/555f0475fa3a00ea796623b6ac89b5271d3426ffa36fe9dc4963d3bc17ee20d4.webp)

Skills
Domain Knowledge

Expertise
Capture Specific Capabilities
Skills capture specific capabilities, domain specific knowledge. PM skill, commit skill, etc

Portable
(Mostly) reusable
Simple and reusable. Some platform dependencies. Requires a sandbox.

### Unix Philosophy for Agents

Agents can compose CLI tools through Bash, discover their usage on demand, and draw on pretraining for familiar tools such as gh and git. Parra highlights local agents with a sandbox and code execution.

[5:58](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=358s) [The slide describes command-line composition, discovery when needed, and pretraining.](https://assets.ai.engineer/sites/aiecode2025/sha256/1a3b5826bd1983819e9c62511dabeca108c20aa99bac6a0f1e4daaf0a5d2df22.webp)

Command Line
Unix Philosophy for Agents

Composition
Bash Tool composition
Pipes, redirects, scripting

Progressive Discovery
Discover usage when needed
Models can explore and discover CLIs when needed

Learned
Pretraining
Particularly strong when pre-trained, e.g. gh, git, etc.

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

[6:06](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=366s) [Slide describing Bash tool composition, discovery of CLI usage, and pretraining.](https://assets.ai.engineer/sites/aiecode2025/sha256/2f33a30cefc551a036d143750d530aa8399a53d246a87dc5f11cff38b36bf499.webp)

Command Line
Unix Philosophy for Agents

Composition
Bash Tool composition
Pipes, redirects, scripting

Progressive Discovery
Discover usage when needed
Models can explore and discover CLIs when needed

Learned
Pretraining
Particularly strong when pre-trained, e.g. gh, git, etc.

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

### Connective Tissue

MCP combines discoverable capabilities and enterprise controls with platform independence, including when no sandbox is available. MCP Apps and forthcoming skills over MCP are listed as experiments.

[6:32](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=392s) [Slide presenting MCP capabilities, platform independence, enterprise governance, and experiments.](https://assets.ai.engineer/sites/aiecode2025/sha256/a8dfe0bd7bb777fde29a8143f259d3f432cd7fc0625634a4cc20466da8de9882.webp)

MCP
Connective Tissue

Semantics
Tools, Resources, Tasks & Co
Typed capabilities and context, discoverable on demand.

Decoupling
Platform independence
Don’t rely on a given platform execution environment / sandbox.

Enterprise
Auth, Governance & Policies
Things, big companies care about. Filtering, auditing, observability

Experiments
MCP Apps, Skills over MCP (soon)
Ship interactive UI or skills through the wire.

Interface text:
AI Engineer Europe
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

### The 2026 Agent

Parra sketches an agent that combines skills, connectors, subagents and tool calls: it offers meeting slots and proposes to book one and draft a brief. He says agents still need work.

[7:16](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=436s) [Conceptual agent interface annotated with skills, tool composition, connectors, tasks, subagents, rich interaction, and discovery.](https://assets.ai.engineer/sites/aiecode2025/sha256/147d4d71ac03ae4815a814cf1d79edcd98ff9c9044f3f9f714937bc71bfa09c0.webp)

The 2026 Agent

Applies skills
Domain knowledge

Composes calls
MCP + CLI as code

Connectors
Connected servers

Long-running tasks
async, surfaced

Runs subagents
local + remote

Rich interaction
MCP Apps

Discovers tools
progressive

Interface text:
Agent
workspace · acme
3 subagents

Schedule the Q3 review and prep the brief.

I found three open slots — pick one and I'll book it and draft the brief from last quarter's notes.

Pick a slot
calendar · mcp app
Tue 14 · 10:00
Wed 15 · 14:30
Thu 16 · 09:00

▸ composing notes =drive.search("Q2 review" ) summary =$llm-
summarize notes/*.md calendar.create_event(slot, attendees)

Connectors
Google Calendar
Gmail
Slack

Task · indexing repo · 2m
14 servers connected

### What we still need to build

Soria Parra turns to the client-side agent harness and the work needed to connect its parts.

[7:39](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=459s) [Orange section slide titled What we still need to build.](https://assets.ai.engineer/sites/aiecode2025/sha256/f57abb2986d301da82a0fb2496cbe40a1f92b3f8479b1f817fec00aadded547a.webp)

What we still need to build

Getting there

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

[7:45](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=465s) [Orange section slide reading “Getting there” and “What we still need to build.”](https://assets.ai.engineer/sites/aiecode2025/sha256/d1c7bae971646135e7c6caee89b2799ca05c1a387ae3842cc4bd497cdc27e234.webp)

What we still need to build

Getting there

Interface text:
AI Engineer EUROPE
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

### Progressive discovery

Tool search defers loading tools until the model needs them. In this Claude Code comparison, tool schemas drop from 56,000+ tokens every turn to about 9,000 tokens discovered on demand.

[8:04](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=484s) [Comparison showing more than 56,000 tool-schema tokens without tool search versus approximately 9,000 tokens discovered on demand with tool search.](https://assets.ai.engineer/sites/aiecode2025/sha256/f7106d49f98d658c04e32d853bb2c144618eb7b94fdea74aa2a9ad9a699de614.webp)

Harness work · 1 of 2
Progressive discovery

Without tool search
56,000+
tokens of tool schemas, every turn

With tool search
~9,000
tokens — discovered on demand

Interface text:
/context
Context Usage
claude-sonnet-4-6 · 87k/200k tokens (44%)
Estimated usage by category
System prompt: 6.6k tokens (3.3%)
System tools: 20.3k tokens (10.2%)
MCP tools: 45.6k tokens (22.8%)
Custom agents: 1.9k tokens (0.9%)
Memory files: 10.2k tokens (5.1%)
Skills: 2.5k tokens (1.2%)
Messages: 86 tokens (0.0%)
Free space: 80k (40.0%)
Autocompact buffer: 33k tokens (16.5%)
MCP tools · /mcp

/context
Context Usage
claude-sonnet-4-6 · 31k/200k tokens (15%)
Estimated usage by category
System prompt: 6.6k tokens (3.3%)
System tools: 9.6k tokens (4.8%)
Custom agents: 1.9k tokens (0.9%)
Memory files: 10.2k tokens (5.1%)
Skills: 2.5k tokens (1.2%)
Messages: 86 tokens (0.0%)
Free space: 136k (68.1%)
Autocompact buffer: 33k tokens (16.5%)
MCP tools · /mcp (loaded on-demand)

### Programmatic tool calling

The model writes code in a REPL to orchestrate tools through an execution environment, then returns the result to the conversation. The script can use loops, branches, and error handling.

[10:00](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=600s) [Slide describing code that orchestrates MCP tools with loops, branches, and error handling, alongside an execution-flow diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/0112f6b2789d61a51a1ebd6143bd6c76000c31a5735128c8cc1437068bbb2542.webp)

Harness work · 2 of 2
Programmatic tool calling

Instead of one tool call per turn, the model writes code that orchestrates MCP tools — loops, branches, error handling.

Conversation → REPL Tool → Execution → Conversation
Execution: MCP, CLI, …

Interface text:
AI Engineer
Engineering the future of AI

[10:15](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=615s) [Slide describing code that orchestrates MCP tools, with a diagram connecting conversation, a REPL, execution, MCP, and CLI.](https://assets.ai.engineer/sites/aiecode2025/sha256/fd2cb39ea63565d72d0c14ef0bcfb45e1d55d22c44a8dc112d5ff33e29bdb8c6.webp)

Harness work · 2 of 2
Programmatic tool calling

Instead of one tool call per turn, the model writes code that orchestrates MCP tools — loops, branches, error handling.

Conversation → REPL Tool → Execution → Conversation
Execution: MCP, CLI, …

Interface text:
AI Engineer EUROPE
PRESENTED BY
Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

### Programmatic tool calling: MCP and CLI

A single REPL call fetches a Linear user through MCP and a GWS user through the CLI, then emits both results as JSON.

[10:32](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=632s) [Code example uses a REPL to call an MCP tool, run a CLI command, and emit their results.](https://assets.ai.engineer/sites/aiecode2025/sha256/65be81dad89f1fc7d7bf2c1abe839e2a3a96f470a2556b1938d3b5f2683bbc07.webp)

Programmatic tool calling: MCP + CLI = ❤️

Conversation: ....

...

Tool Call: REPL

const linear_user = await mcp.call_tool(
   “linear_get_user_info”,
   { id: “…” }
);
const gws_user = await exec(
   “gws”, [“get-user”, id]
);
emit(
  gws_user, linear_user,
  {format: “json”}
);

### Build for agents

Build tools around clear intent, use a sandbox for orchestration, and ship MCP Apps for canvas interactions. The speaker warns that one-to-one REST conversions make poor agent tools.

[11:58](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=718s) [Slide recommends designing tools for agents, using Code Mode for orchestration, and shipping an MCP app for canvas interactions.](https://assets.ai.engineer/sites/aiecode2025/sha256/fa227702f93b57f23775c62b6137eb10fab82c5e62c375ac14541f52849526ba.webp)

Server work
Build for agents

Design for the agent
Or for a human — that’s a good proxy. Ground-up tools with clear intent, not thin SDK wrappers over a REST surface.
e.g. Sentry MCP

Reach for Code Mode
When the job is orchestration, expose a sandbox and let the model write the glue.
e.g. Cloudflare MCP

Ship an MCP App
When interaction wants a canvas, send one through the wire instead of forcing it through text.
e.g. Excalidraw MCP

### MCP in 2026

The MCP roadmap spans core improvements, broader integration, and experimental extensions. A proposed stateless transport aims to make MCP servers easier to scale and deploy.

[13:42](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=822s) [Slide outlining improvements to MCP core, integration, and experimental extensions.](https://assets.ai.engineer/sites/aiecode2025/sha256/0e6e1f2bbbcf6db40984f4f3200bfd976010a221e0a75bdf17b22380f8f5a971.webp)

Protocol Work
MCP in 2026

Improved Core
Stateless Transport
Improved Tasks
Typescript SDK v2.0
Python SDK v2.0

Integrate everywhere
Cross-App-Access
Server Discovery via Server-Cards
`.well-known/mcp-server-card/server.json`

Pushing the boundary
Experimental extensions:
Skills over MCP

Interface text:
THE FUTURE OF MCP
Braintrust
WorkOS
OpenAI

### 2026 is about connectivity

Parra expects agents to combine computer use, CLIs, MCP and skills so they can do a wider variety of things.

[17:48](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1068s) [Quotation slide stating that 2026 is about connectivity and that the best agents use every available method.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb8fcff9f8afb51bae220ec5fa021dd510f0a73c24180a5884f5fff1c9e8eecf.webp)

“2026 is all about connectivity. The best agents use every available method.”

Interface text:
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC
AI Engineer EUROPE
PRESENTED BY Google DeepMind

### Interactive camera diaphragm demo

The aperture slider adjusts overlapping blades, changing the opening and how much light enters the lens. Previews show light and depth of field. Parra says the shipped feature uses an MCP application to render content.

[18:04](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1084s) [A chat interface displays a camera aperture diagram, an aperture slider, and a depth-of-field preview.](https://assets.ai.engineer/sites/aiecode2025/sha256/d260659746234b96f927d68a9a56bd691ee1845a3f05323f9ca1bab2bbf037b5.webp)

show interactive explanation how camera diaphragm works

A camera diaphragm controls how much light enters the lens using overlapping metal blades that form an adjustable opening. Drag the slider to see how it works.

Aperture: f/5.6
Aperture scale: 22, 16, 11, 8, 5.6, 4, 2.8, 2, 1.4

Light reaching sensor
dim — needs slow shutter or high iso

Depth of field preview
subject in focus
moderate — some separation

Opening area: 8%
Stops from wide: -3.7

f/1.4 portrait
f/5.6 street
f/16 landscape
why hexagonal? ↗

Interface text:
Chat  Cowork  Code
Educational SVG diagrams project
Reply...
Opus 4.6
Claude is AI and can make mistakes. Please double-check responses.

AI Engineer EUROPE
PRESENTED BY Google DeepMind
THE FUTURE OF MCP
DAVID SORIA PARRA / Member of Technical Staff
ANTHROPIC

### Zipf’s Law visualization

A generated graph illustrates Zipf’s Law: “the” has roughly twice the frequency of “of,” while a dashed curve falls as word rank increases.

[18:25](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1105s) [A descending frequency-versus-rank curve with bars for the words “the” and “of.”](https://assets.ai.engineer/sites/aiecode2025/sha256/14dd8a0bd5f4790056ef45c241f1c013d28a54f7ca9fadc607a1a5e132bbc83b.webp)

explain Zipf's Law visually

Zipf's Law says the frequency of a word is inversely proportional to its rank. The most common word in English ("the") appears roughly twice as often as the second ("of"), three times as often as the third, and so on. Rank × frequency ≈ constant.

Chart labels: the, of
Y-axis: frequency
X-axis: rank
X-axis tick: #1

Interface text:
Chat
Cowork
Code
Educational SVG diagrams project
Reply...
Opus 4.6
Claude is AI and can make mistakes. Please double-check responses.

## Full transcript

[0:00](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=0s) [upbeat music] Well, welcome.

[0:18](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=18s) Let's get started. This is an MCP application. That's an agent shipping its own interface, not through like a plugin, not through an SDK, not rendered on the fly by the model on the client side, or hard-coded into the product.

[0:37](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=37s) That is something that is served over an MCP server, and you can take the server, put it into Claude, you can put it into ChatGPT, you can put it into VS Code, Cursor, and it will just fucking work.

[0:50](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=50s) And that, I think, is kinda cool because for doing that, you need something that a lot of things that we're-- want in the ecosystem do not offer. You need semantics.

[1:00](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=60s) You need to have both sides, the client and the server, to understand what each side is talking, to understand how you render this, understand that there's a UI coming.

[1:10](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=70s) And for that, you need a protocol. And the best part about this, an MCP server doesn't just ship an app or can ship an app, it can also ship tools with it, and so you can interact with it, with the application as a human, and you can have the model interact with it through tools, which is, I

[1:28](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=88s) think, a very unique thing that I think we have not explored much just yet. Okay. But let's quickly rewind a little bit from this, what I think is a really cool glimpse into the future of MCP into over a year ago, eighteen months, an eternity in AI life cycle, um, all of this did not exist.

[1:50](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=110s) There was just a little spec document, a few SDKs, uh, mostly written by Claude, local only, with little more than just tools. And in that last eighteen or twelve months, you guys have been absolutely crazy building stuff, um, building servers, building, um, and crazy ecosystem around this.

[2:08](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=128s) And we on our side have been busy, busy taking this local only thing, added remote capabilities, added centralized authorization, added new primitives like elicitation and tasks, and last but not least, added new experimental features to the protocol like the MCP applications that you've just seen.

[2:30](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=150s) And in the meantime, we have reached, I think, a really cool milestone because, again, you-- all of you have been absolutely crazy building, building, and building, of course, luckily with the help of, uh, a bunch of agents.

[2:41](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=161s) Um, we're now like at a hundred ten million monthly downloads, and that's just, of course, not us using it in our clients and servers. That's like OpenAI's Agents SDK, it's Google's ADK, it's LangChain, thousands of frameworks and tools that you might have never even heard of it, pulling it as a de- as a dependency, which means there's

[3:02](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=182s) one common standard that all of us have at our disposal to speak to each other. Um, just a bit for context, uh, React, one of the most successful, um, uh, open source projects probably of the last decades, took roughly double the amount of time to reach that download volume.

[3:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=200s) And in the meantime, of course, you all have been building really, really cool servers from like little toy projects of WhatsApp servers and Blender servers, uh, to building SaaS integrations like Linear, Slack, and Notion that are really powering what everyone does every day when they use MCPs.

[3:34](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=214s) But most importantly, the vast majority of MCP server most of all of us have built are behind closed doors, uh, connecting company systems to agents, uh, and AI applications.

[3:46](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=226s) But I still think this is just the absolute beginning of where we are

[3:51](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=231s) because I think twenty twenty-five was all about exploring, and twenty twenty-six is all about putting these agents into production. Because if you really think about, in my mind, twenty twenty-four, we just built a bunch of like demos and showed cool stuff to people, and there was a little bit of a buzz there.

[4:08](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=248s) Twenty twenty-five was really all about coding agents. But coding agent, if you really think about, are the most ideal scenario for an agent. It's local, it's verifiable. You can call a compiler.

[4:19](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=259s) Like you have a developer who can fix shit if it goes wrong in front of the, in front of the computer. Uh, and you can display a GUI interface, and the user is quite happy.

[4:31](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=271s) But I think now with the capabilities of the model increasing, we are going into a new era, which I think this year will be-- we will see the start, where we're not just doing coding agents, we're gonna have general agents that will do real knowledge worker stuff, like things a financial analysis-- uh, analyst wanna do, uh, a

[4:49](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=289s) marketing person wanna do, and they need one thing in particular. They don't need a local agent that calls a compiler. What they need is something that could connect to like five SaaS applications and a, and a shared drive because the most important part for them for an agent is connectivity.

[5:06](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=306s) And in my mind, connectivity is not one thing. If one-- if someone tells you there's one solution to all your connectivity problem, be it computer use, be it CLIs, be it MCP, they are probably pretty wrong.

[5:18](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=318s) Because the right, because the right thing, of course, is that it always means it depends, and there is a real, a big connectivity stack, and there's a right tool for the right job.

[5:28](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=328s) And in my mind, there are three major things that you wanna consider building an agent in twenty twenty-six. It's skills, MCP, and of course like CLI or computer use, depending on your use case.

[5:38](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=338s) And they have three very distinct things that they can do and three different things you wanna consider when you build your agent. Number one, skills, of course, is just like domain knowledge.

[5:49](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=349s) It's just like capture specific capabilities, put into a very simple file, and it's mostly reusable. There are some minor differences between the different platform.

[5:59](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=359s) Of course, CLI is very popular when local coding agents. It's an amazing tool-

[6:04](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=364s) To get simply started, to have something that you can compose in a bash that you-- that automatically discover, where the model can automatically discover what the CLI is capable of.

[6:13](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=373s) And most importantly, if you have things that are like CLIs, like GitHub, Git, and other things that are in pre-training, CLI is an amazing solution for your connectivity part, and they're particularly good when you have a local agent where you can assume a sandbox, where you can assume a code execution environment.

[6:31](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=391s) But if you don't have this, if you need rich semantics, when you need a UI that can display long-running tasks, when you can have-- when you need things like resources, when you need to build something that is fully decoupled and needs platform independence, or you don't have a sandbox, when you need things like authorization, governance, policies, or

[6:51](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=411s) short to say boring enter- boring but important enterprise stuff, or if you wanna have experiments like MCP applications or what comes soon, skills over MCP, then I think MCP is this, like, additional connective tissue that is just yet another tool in the toolbox for you to build an amazing agent.

[7:12](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=432s) And so this is all to say that I think in 2026, we're gonna start building agents that use all of it. They don't use one thing, they use all of it, and they use them quite seamlessly together.

[7:24](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=444s) But I don't think we're quite there just yet because we need to build a lot of stuff, partially, um, because our agents kinda still suck, um, and partially because I think we just haven't talked enough about, like, some of the techniques you can do, uh, to really put this connective tissue together.

[7:47](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=467s) The number one thing that we need to go and start building is on the client side, on the s- on the agent harness side, on the things that powers the connective parts, that be it a Claude Code, uh, be it a Pi, be it whatever application you're gonna build.

[8:04](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=484s) And the number one thing we're gonna do there and what we all have to do and something I wanna really get across today, is that we need to go and start s- building something called progressive discovery.

[8:14](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=494s) Most people, when they think about like, oh, uh, MCP, they can think about, like, context load. But if you really consider what a protocol does, a protocol just puts information across a wire, but the client is responsible for dealing with that information.

[8:29](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=509s) And what everybody so far has done, because we're in this very early experimentation phase, is to simply put all the tools into the context window and then be quite surprised that maybe the context window gets large.

[8:40](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=520s) Um, but what you can do instead, and what you should do instead, you should start using this progressive discovery pattern, which is to say, use something like tool search to defer the loading of the tools and start loading the tools when the model needs it.

[8:58](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=538s) And we have this in the Anthropic product, in the API, um, people can use this, uh, on, on competitors' APIs as well. But also you can just build this in yourself, where you just don't load the tool directly, and the moment you give the, you give the model a tool loading tool, basically, and the model goes like,

[9:15](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=555s) "Ah, maybe I need a tool now. Let me look up what tools I need." And then you load them on demand.

[9:21](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=561s) And here in this example, what you're seeing is on the left side is, uh, Claude Code before we'd added this to Claude Code and then after it, uh, uh, to Claude Code.

[9:30](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=570s) So you see a massive reduction in tool, uh, use-- uh, tool context usage. The second part to that is, is something called programmatic tool calling or what other people usually refer to, um, to code mode.

[9:47](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=587s) Um, this is the idea that one thing that you really wanna do is you wanna compose things together. You don't want the model to go call a tool, take the result, then go and talk, call another tool, take the result, call another tool.

[10:03](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=603s) Because what you're effectively doing is you're letting the model orchestrate things together, and in that orchestration, you're using inference, you're u-- it's, it's latency sensitive, and all of its stuff could be done way more effective if you would instead write

[10:19](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=619s) a script. Um, and in fact, that's actually what you constantly do and what you constantly see things like Claude Code do when it writes the bash command. But you can of course do this with everything, and you can do this with MCP, and you should do this with MCP.

[10:33](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=633s) So what does this mean? So what you want, instead of having one tool after another, you want to give the model a REPL tool, provide like a com-- like a execution environment like a V8 isolate or a Monty or something like that, or a Lua interpreter, and just have the model write the code for you, and the

[10:52](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=652s) model just executes that code and then composes them together. And there's a neat little feat- feature in MCP called structured output that tells you what the return value of the output will be.

[11:05](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=665s) And the model can use this information to, uh, to figure out type information, which then mean it can really nicely compose these things together. And in this example here, instead of doing two different calls, you do one call, and you can filter.

[11:19](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=679s) The, the model will automatically ex-- uh, remove things from a JSON and just continue.

[11:26](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=686s) Of course, if you don't have a structured output, you can always just ask the model to give you a structured output, um, uh, by just extracting it and saying, "Hey, call a cheap model," and say, "I want this expected type.

[11:39](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=699s) Give it back to me." And bam, you have a type. The model can compose things together. And I think this is something we're just not doing enough yet, and this is, I think, something where we can improve our agent harnesses.

[11:50](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=710s) And then last but not least, of course, you can just compile-- compose these things together with executables, like with CLIs, with other components, with APIs as well.

[11:59](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=719s) Um, next, what we need to do, besides the client work, which is progressive discovery and Um, programmatic tool calling, we need to go and start building properly for agents.

[12:10](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=730s) And that means we all need to stop taking REST APIs and put them one-to-one into, uh, an MCP server. Every time I see someone building another REST to MCP server, a conversion tool, I'm-- it's a bit cringe because I think it just, it just results in horrible things.

[12:28](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=748s) Um, and what you should do instead, you should design for an agent. Or basically, you can start designing for you as a human, how you would wanna interact with this, because that's actually a very, very good start for an agent.

[12:40](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=760s) If you wanna orchestrate things together, you should reach, of course, for programmatic tool calling, and you can do this on the client side, as I said before, but you can also do this on the server side.

[12:50](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=770s) The Cloudflare MCP server and others like that are great examples how you can have, instead of providing tools, provide an execution environment to the model and then just have them orchestrate things together, which again, cuts on token usages, uh, cuts on latency, uh, and is way more powerful in its composition.

[13:09](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=789s) And then last but not least, you should start, and we should start as server authors, to use this rich semantics that MCP offers over alternatives. This means shipping MCP applications.

[13:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=800s) It means shipping, um, skills over MCP. It means, um, using, uh, things like task and other aspects that the protocol offers that were currently slightly underused, or things like elicitations, things that only MCP can do for you.

[13:36](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=816s) And of course, that's all the work you all need to do, and maybe some of our product people need to do. We also need to do a lot of work on MCP itself.

[13:44](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=824s) And there's a few things down the line that we're gonna go and have to go and solve. The number one thing is we need to improve the core. There's a few things that as we have developed the protocol over the last year, that are just not in a good shape.

[13:58](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=838s) Number one is that the current Streamable HTTP, it's very hard to scale if you're a large hyperscaler. And so we have a proposal from, uh, our friends at Google, um, who are working with something called a stateless transport protocol, which make it significantly easier to just treat MCP servers like, uh, you know, another stateless, uh, REST

[14:20](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=860s) server or something like that that we used to know how to deploy to like Cloud Run or Kubernetes and so on. So that's coming down in June and hopefully landing in the SDKs very soon.

[14:31](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=871s) In addition, we need to improve our asynchronous task primitive, which basically is a very fancy way to say we just wanna have agent-to-agent communication. We have a very experimental version of the protocol that very few clients support, so we're gonna start building more clients out like that, and most importantly, we are improving some of the little semantics

[14:51](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=891s) that we need to do. We're gonna ship a TypeScript version, uh, SDK version two and Python SDK version two based on, um, a lot of the lessons learned, uh, over the last year.

[15:01](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=901s) There's a, there's a, um, a, a, a SDK called FastMCP. Uh, who's using FastMCP? Yeah. It's just way fucking better than Python SDK that we're shipping, right? And that's on me because I wrote the Python SDK.

[15:14](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=914s) Um, and, and so I have a bunch of people who are way better Python developers than me help me, uh, write it better. Um, the second part is we need to start integrating everywhere.

[15:24](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=924s) We're gonna ship for, particularly for enterprises, something called cross-app access. It's a new thing that we're working closely together with identity providers, which just allows you-- It's a very fancy way to say, uh, once you log in once with your local company identity provider, be it a Google, be it an Okta, you will be able to just

[15:40](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=940s) use MCP servers without having to re-log in. So it's a bit more smoothness. Um, in addition, we're gonna add something called a server discovery by, um, so by, uh, specifying, uh, how you can discover servers on well-known URLs automatically.

[15:55](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=955s) So crawlers, browsers, um, agents can just go to a website and say, "Oh, um, instead of just parsing the website, is there also an MCP server I can use?"

[16:05](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=965s) And we will be able to automatically discover this. This is a really cool thing that will come down, uh, also in June when we launch the next specification, uh, and will be supported there.

[16:14](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=974s) And then last but not least, we are starting to use our extension mechanisms in, in MCP, which means that some clients will support this, like for example, MCP applications will only be supported by web-based interfaces because if you're a CLI, you just have a hard time rendering HTML, right?

[16:31](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=991s) Um, and we'll do more of these extensions. One of the most exciting extensions that I think is, is cool, we're just gonna ship skills over MCP because it's very obvious that if you have a large MCP server with tons and tons of tools, you just wanna ship domain knowledge with it and say, "Oh, this is how

[16:46](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1006s) you're supposed to use this. This is how you're supposed to use this." And it allows you as a server author to continuously ship updated skills without having to rely on plugin mechanisms and registries and other stuff.

[16:57](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1017s) So that's coming down. Um, there's a lot, a lot of experimentation from people already in that space. You can already do some of that today if you just give the model a load skills tool.

[17:07](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1027s) Like you can, you can build primitives of versions of this today without having to rely on the semantics, but of course we're gonna define the semantics. Okay. So that's for me, a long-winded way to think, to say that I think MCP is actually in a really good shape, and I think in this year we're gonna push, uh,

[17:25](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1045s) agents to full connectivity. Um, MCP will continue to play a major, major, major role. And we want, of course, your feedback. We are a very open community. We just have created a foundation.

[17:37](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1057s) We're mostly running as an open source community with a Discord, with issues. Um, just come to us and tell us where the fuck are we wrong? What are we getting right?

[17:46](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1066s) Um, so that we can improve this on a continuous basis. So twenty twenty-six I think is all about connectivity, and the best agents use every available method. They will use computer use, they will use CLIs, they will use MCPs, and they will use, will use skills because they wanna have a wide variety of things they can do,

[18:04](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1084s) and then they can ship cool stuff like this, um, which is, um,

[18:11](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1091s) one of the product features we shipped recently. Uh, under the hood, it's nothing but an MCP application, um, that renders stuff, right? Cool.

[18:24](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1104s) So we can now look at, uh, the model writing graphs.

[18:27](https://www.youtube.com/watch?v=v3Fr2JR47KA&t=1107s) Anyway, thank you. [upbeat music]
