The Future of MCP — David Soria Parra, Anthropic

0:07[music]

0:15>> Well,

0:16welcome.

0:18Let's get started.

0:21This

0:22is an MCP application.

0:25That's an agent shipping its own

0:27interface not through like a plugin, not

0:29through an SDK,

0:30not rendered on the fly by the model on

0:33the client side, or hardcoded into the

0:36product. That is something that is

0:38served over an MCP server, and you can

0:40take the server, put it into cloud, you

0:42can put it into ChatGPT, you can put it

0:44into VS Code Cursor, and it will just

0:46work.

0:50And that

0:52I think it's kind of cool because for

0:53doing that, you need something that a

0:55lot of things that we're want in the

0:58ecosystem do not offer. You need

0:59semantics, you need to have both sides,

1:01client and the server, to understand

1:04what each side is talking, to understand

1:06how you render this, understand that

1:08there's a UI coming.

1:10And for that, you need a protocol.

1:13And the best part about this,

1:15an MCP server doesn't just ship an app,

1:18or can ship an app, it can also ship

1:20tools with it, and so you can interact

1:22with it with the application as a human,

1:25and you can have the model interact with

1:26it through tools, which is I think a

1:28very unique thing that I think we have

1:30not explored much

1:32just yet.

1:34Okay.

1:35But, let's quickly rewind a little bit

1:37from this what I think is a really cool

1:40glimpse into the future of MCP into over

1:43a year ago, 18 months, an eternity in AI

1:46life cycle, um all of this did not

1:49exist. There was just a little spec

1:51document, a few SDKs, uh mostly written

1:54by Claude, local only with little more

1:57than just tools. And in that last 18 or

2:0012 months, you guys have been absolutely

2:02crazy building stuff, um building

2:05servers, building um an crazy ecosystem

2:07around this, and we on our side have

2:09been busy busy taking this local only

2:12thing, added remote capabilities, added

2:15centralized authorization, added new

2:18primitive like elicitation and tasks,

2:21and last but not least, added new

2:23experimental features to the protocol

2:25like the MCP applications that you've

2:27just seen.

2:30And in the meantime,

2:32we have reached, I think, a really cool

2:33milestone because again, you all of you

2:35have been absolutely crazy building,

2:37building, and building. Of course,

2:38luckily with the help of a a bunch of

2:40agents. Um

2:42we're now like at 110 million

2:45monthly downloads. And that's just, of

2:47course, not us using it in our clients

2:49and servers. That's like OpenAI's agent

2:52SDK, that's Google's ADK, that's

2:54LangChain, thousands of frameworks and

2:56tools that you might have never ever

2:58heard of it pulling it as a

2:59as a dependency, which means there's one

3:02common standard that all of us have at

3:05our disposal to speak to each other. Um

3:09just a bit for context, uh React, one of

3:11the most successful um

3:13open source projects probably of the

3:15last decades, took roughly double the

3:17amount of time to reach that download

3:18volume.

3:20And in the meantime, of course, you all

3:21have been building really, really cool

3:22servers from like little toy projects of

3:24WhatsApp servers and Blender servers, uh

3:27to building SAS integrations like

3:28Linear, Slack, and Notion that are

3:30really powering what everyone does every

3:32day when they use MCPs. But most

3:34importantly, the vast majority of MCP

3:37server most of all of us have built are

3:38behind closed doors uh connecting

3:40company systems to agents uh and AI

3:44applications.

3:46But I still think this is just the

3:47absolute beginning of where we are.

3:51Because I think 2025 was all about

3:54exploring, and 2026 is all about putting

3:57these agents into production. Because if

3:59you really think about it, in my mind,

4:012024, we just built a bunch of like

4:03demos and showed some cool stuff to

4:05people, and there was a little bit of a

4:07buzz there. 2025 was really all about

4:10coding agents. But coding agent, if you

4:12really think about it, are the most

4:14ideal scenario for an agent. It's local,

4:17it's verifiable, you can call a

4:18compiler, like you have a developer who

4:21can fix if it goes wrong in front

4:23of the in front of the computer, uh and

4:26you can display a UI interface, and the

4:28user's quite happy.

4:30But I think now with the capabilities of

4:32the model increasing, we're going into a

4:35new era, which I think this year will be

4:37we will see the start, where we're not

4:39just doing coding agents, we're going to

4:41have general agents that will do real

4:43knowledge worker stuff, like things a

4:45financial analysis analyst want to do,

4:48uh a marketing person want to do. And

4:50they need one thing in particular. They

4:54don't need a local agent that calls a

4:55compiler. What they need is something

4:57that could connect to like five SAS

4:59applications and a and a shared drive

5:02because the most important part for them

5:04for an agent is connectivity.

5:06And in my mind, connectivity is not one

5:09thing. If one if someone tells you

5:11there's one solution to all your

5:12connectivity problem, be it computer

5:13use, be it CLIs, be it MCP,

5:16they are probably pretty wrong because

5:18the right because the right thing, of

5:19course, is that it always means it

5:21depends, and there's a real a big

5:23connectivity stack, and there's a right

5:26tool for the right job. And in my mind,

5:28there are three major things that you

5:30want to consider building an agent in

5:312026. It's skills, MCP, and of course,

5:34like CLI or computer use depending on

5:37your use case. And they have three very

5:39distinct things that they can do in

5:41three different things you want to

5:43consider when you build your agent.

5:46Number one, skills, of course, is just

5:48like domain knowledge, it's just like

5:50capture-specific capabilities put into a

5:52very simple file, and it's mostly

5:54reusable. There are some minor

5:56differences between the different

5:57platform.

5:59Of course, CLIs very popular when local

6:01coding agents. It's an amazing tool to

6:04get simply started, to have something

6:06that you can pose in a bash, that you

6:08that automatically discover where the

6:10model can automatically discover what

6:11the CLI is capable of. And most

6:13importantly, if you have things that are

6:16like CLIs, like GitHub, Git, and other

6:18things that are in pre-training, CLI is

6:20an amazing solution for your

6:22connectivity part, and they're

6:24particularly good when you have a local

6:26agent where you can assume a sandbox,

6:28where you can assume a code execution

6:30environment.

6:31But if you don't have this, if you need

6:33rich semantics, when you need a UI that

6:36can display long-running tasks, when you

6:37can have when you need things like

6:39resources, when you need to build

6:41something that is full decoupled and

6:43needs platform independence, or you

6:45don't have a sandbox, when you need

6:47things like authorization, governance,

6:50policies, or short to say boring enter

6:52boring but important enterprise stuff,

6:55or if you want to have experiments like

6:58MCP applications or what comes soon,

7:01skills over MCP, then I think MCP is

7:04just like additional connective tissue

7:06that is just yet another tool in the

7:08toolbox for you to build an amazing

7:10agent.

7:12And so this is all to say that I think

7:13in 2026, we're going to start building

7:16agents that use all of it. They don't

7:18use one thing, they use all of it, and

7:20they use them quite seamlessly together.

7:24But I don't think we're quite there just

7:27yet.

7:28Because we need to build a lot of stuff

7:31partially um because

7:34our agents kind of still suck.

7:36Um and partially because I think we just

7:38haven't talked enough about like some of

7:40the techniques you can do

7:42uh to really put this connective tissue

7:44together.

7:47The number one thing that we need to go

7:49and start building is on the client

7:51side, on the on the agent harness side,

7:54on the things that powers the connective

7:56parts, that be it a cloud code, uh be it

8:00a pie, be it whatever application you're

8:02going to build.

8:04And the number one thing we're going to

8:05do there, and what we all have to do,

8:07and something I want to really get

8:08across today, is that we need to go and

8:10start building something called

8:11progressive discovery.

8:14Most people when they think about like,

8:16"Oh,

8:17I MCP," they can't think about like

8:19context load. But if you really consider

8:22what a protocol does, the protocol just

8:23puts information across the wire, but

8:26the client is responsible for dealing

8:28with that information. And what

8:29everybody so far has done because we're

8:31in this very early experimentation

8:33phase, is to simply put all the tools

8:35into the context window, and then be

8:37quite surprised that maybe the context

8:38window gets large. Um

8:41but what you can do instead, and what

8:43you should do instead, you should start

8:45using this progressive discovery

8:48pattern,

8:49which is to say, use something like tool

8:51search to defer the loading of the

8:54tools, and start loading the tools when

8:57the model needs it. And we have this in

9:00the Anthropic API, and people can use

9:03this uh on on competitors' APIs as well.

9:06But also, you can just build this in

9:07yourself where you just download the

9:09tool directly, and the moment you give

9:11the you give the model a tool loading

9:13tool, basically, and the model goes

9:14like, "Ah, maybe I need a tool now. Let

9:16me look up what tools I need." And then

9:18you load them on demand.

9:21And here in this example, what you're

9:22seeing is on the left side is uh Claude

9:25Code before we added this to Claude

9:27Code, and then after it uh

9:29to Claude Code. So you see a massive

9:31reduction

9:33in tool

9:35uh use uh tool context usage.

9:39The second part of that is is something

9:40called programmatic tool calling, or

9:42what other people usually refer to um

9:45to code mode.

9:46Um this is the idea that one thing that

9:50you really want to do is you want to

9:52compose things together. You don't want

9:56the model to go call a tool, take the

9:58result, then go and talk, call another

10:00tool,

10:02take the result, call another tool.

10:03Because what you're effectively doing is

10:05you're letting the model orchestrate

10:06things together, and in that

10:08orchestration, you're using inference,

10:09you're it's it's latency sensitive, and

10:12all of it stuff could be done way more

10:13effective if you would instead write

10:18a script.

10:20Um

10:21and in fact, that's actually what you

10:22constantly do and what you constantly

10:24see things like hard code do when it

10:26writes the bash command. But you can of

10:28course do this with everything, and you

10:29can do this with MCP, and you should do

10:31this with MCP. So, what does this mean?

10:34So, what you want instead of having one

10:37tool at another, you want to give the

10:39model a repple tool, provide like a like

10:42a execution environment, like a V8

10:44isolate or a monty or something like

10:46that, or a lua interpreter, and just

10:49have the model write the code for you,

10:51and the model just executes that code,

10:54and then composes them together. And

10:56there's a neat little feature in MCP

10:58called structured output that tells you

11:01what the return value of the output will

11:04be, and the model can use this

11:06information to to figure out type

11:08information, which then mean it can

11:10really nicely compose these things

11:12together. And in this example here,

11:15instead of doing two different calls,

11:17you do one call, and you can filter that

11:19the model will automatically

11:21remove things from a JSON and just

11:24continue.

11:26Of course, if you don't have uh

11:28structured output, you can always just

11:30ask the model to give you structured

11:31output

11:32um

11:33uh by just extracting it and saying,

11:35"Hey, call us cheap model and say, 'I

11:37want this expected type, give it back to

11:39me.'" And bam, you have a type, the

11:41model can compose things together, and I

11:43think this is something we're just not

11:44doing enough yet, and this is I think

11:46something where we can improve our agent

11:48harnesses.

11:49And then last but not least, of course,

11:51you can just compile compose these

11:52things together with executables, like

11:54with CLIs, with other components, with

11:56APIs as well.

11:59Um next, what we need to do besides the

12:01client work, which is progressive

12:03discovery and

12:05um programmatic tool calling, we need to

12:07go and start building properly for

12:09agents. And that means we all need to

12:12stop taking rest APIs and put them

12:14one-to-one

12:16into

12:17uh an MCP server. Every time I see

12:20someone building another rest to MCP

12:22server a conversion tool, I'm it's a bit

12:24cringe because I think it's just it just

12:26results in horrible things.

12:28Um and what you should do instead, you

12:30should design for an agent. Or

12:31basically, you can start designing for

12:33you as a human, how you would want to

12:34interact with this, because that's

12:36actually a very, very good start for an

12:39agent.

12:40If you want to orchestrate things

12:41together, you should reach, of course,

12:44for programmatic tool calling, and you

12:45can do this on the client side, as I

12:47said before, but you can also do this on

12:49the server side. The Cloudflare

12:51MCP server and others like that are

12:53great examples how you can have, instead

12:56of providing tools, provide an execution

12:59environment to the model and then just

13:00have them orchestrate things together,

13:02which again cuts on token usages,

13:05cuts on latency, and is way more

13:07powerful in its composition. And then

13:09last but not least, you should start and

13:11we should start as server authors to use

13:13this rich semantics that MCP offers over

13:16alternatives. This means shipping MCP

13:19applications, it means shipping

13:21skills over MCP, it means

13:24um using things like task and other

13:26aspects that the protocol offers that

13:29we're currently slightly underused, or

13:31things like elicitations.

13:33Things that only MCP can do for you.

13:35And of course,

13:37that's all the work you all need to do,

13:39and maybe some of our product people

13:41need to do, we also need to do a lot of

13:42work on MCP itself. And there's a few

13:45things down the line that we're going to

13:47go and have to go and solve.

13:49The number one thing is we need to

13:51improve the core. There's a few things

13:53that, as we have developed the protocol

13:55over the last year, that are just not in

13:57a good shape. Number one is that the

13:59current streamable HTTP is very hard to

14:01scale if you're a large hyperscaler.

14:04>> [snorts]

14:04>> And so, we have a proposal from our

14:07friends at Google,

14:08who are working on something called a

14:10stateless transport protocol, which make

14:12it significantly easier to just treat

14:16MCP servers like

14:18you know, another stateless uh rest

14:20server or something like that and we are

14:21used to know how to deploy to like cloud

14:24runs or kubernetes and so on. So, that's

14:27coming down in June and hopefully lining

14:29in the SDKs very soon.

14:31In addition, we need to improve our

14:33asynchronous task primitive, which

14:36basically is a very fancy way to say we

14:38just want to have agent-to-agent

14:39communication. We have a very

14:41experimental version of the protocol

14:42that very few clients support, so we're

14:44going to start building more clients out

14:47like that, and most importantly, we are

14:49improving some of the little semantics

14:51that we need to do. We're going to ship

14:52a TypeScript version SDK version two and

14:55Python SDK version two based on a lot of

14:58the lessons learned over the last year.

15:01There's a there's a

15:04SDK called fast MCP.

15:06Who's using fast MCP? Yeah. It's just

15:09way better than Python SDK that

15:11we're shipping, right? And that's on me

15:12because I wrote the Python SDK.

15:14Um and and so, I have a bunch of people

15:16who are way better Python developers

15:17than me help me write it better. Um the

15:20second part is we need to start

15:23integrating everywhere. We're going to

15:24ship for particularly for enterprises

15:26something called cross-app access. It's

15:28a new thing that we're working closely

15:29together with identity providers, which

15:31just allows you It's a very fancy way to

15:33say

15:34once you log in once with your local

15:35company identity provider, be it a

15:37Google, be it an Okta, you will be able

15:39to just use MCP servers without having

15:41to re-login. So, it's a bit more

15:43smoothness. Um in addition, we're going

15:45to add something called a server

15:47discovery by

15:49by specifying how you can discover

15:53servers on well-known URLs

15:55automatically. So, crawlers, browsers,

15:58um

15:58agents can just go to a website and say,

16:01"Oh, I'm instead of just parsing the

16:02website, is there also an MCP server I

16:04can use?" And we will be able to

16:06automatically discover this.

16:07This is a really cool thing that will

16:09come down also in June when we launch

16:11the next specification

16:13and will be supported there.

16:14And then last but not least, we're

16:16starting to use our extension mechanisms

16:18in in MCP, which means that some clients

16:21will support this, like for example, MCP

16:23applications will only be supported by

16:25web-based interfaces, because if you're

16:28a CLI, you just have a hard time

16:29rendering HTML, right? Um and we will do

16:32more of these extensions. One of the

16:33most exciting extensions that I think is

16:35is cool, we're just going to ship skills

16:37over MCP, because it's very obvious that

16:40if you have a large MCP server with tons

16:42and tons of tools, you just want to ship

16:43the main knowledge with it and say, "Oh,

16:46this is how you're supposed to use this.

16:47This is how you're supposed to use

16:48this." And it allows you as a server

16:50author to continuously ship updated

16:53skills without having to rely on plugin

16:55mechanisms on registries and other

16:57stuff.

16:57So, that's coming down.

16:59Um

17:00there's a lot a lot of experimentation

17:01from people already in that space. You

17:03can already do some of that today if you

17:04just give the model a load skills tool.

17:07Like there you can you can build

17:08primitives or versions of this today

17:10without having to rely on the semantics,

17:12but of course, we're going to define the

17:13semantics.

17:15Okay. So, that's for me a long-winded

17:17way to think to say that I think MCP is

17:20actually in a really good shape, and I

17:21think in this year, we're going to push

17:24uh

17:25agents to full connectivity,

17:27um MCP will continue to play a major,

17:30major, major role. And we want, of

17:32course, your feedback. We are very open

17:34community. We are just have created a

17:35foundation. We're mostly running as an

17:38open-source community with a discord,

17:40with issues. Um just come to us and tell

17:43us where the are we wrong, what are

17:45we getting right, um so that we can

17:46improve this on a continuous basis.

17:49So, 2026, I think is all about

17:51connectivity, and the best agents use

17:54every available method. Like they will

17:55use computer use, they will use CLIs,

17:57they will use MCPs, and they will use

17:59will use skills.

18:01Because they want to have a wide variety

18:03of things they can do, and then they can

18:05ship cool stuff like this,

18:07um

18:08which is

18:10um

18:11one of the product features we shipped

18:13recently.

18:14Uh under the hood, it's nothing but an

18:16MCP application

18:18um that renders stuff, right?

18:21Cool.

18:23So, we can now look at uh the model

18:25writing graphs.

18:27Anyway,

18:29thank you.

18:38>> [music]