# Full Spec MCP: Hidden Capabilities of the MCP Spec — Harald Kirschner, Microsoft/VS Code

Harald Kirschner

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/ExeD-8gFUMM-full-spec-mcp-hidden-capabilities-mcp-spec) · [Video](https://www.youtube.com/watch?v=ExeD-8gFUMM)

## Full Spec MCP: Hidden Capabilities of the MCP Spec

MCP can do more than expose functions: dynamic discovery, resources, sampling and user input let servers adapt as a task and its context change.

You should be familiar with MCP clients and servers, model tool calling, and basic Python.

### Why does an MCP server fail to work?

[0:00](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=0s)

Who has built an MCP server and found that it did not work? That opening question reaches beyond connection errors. A server can expose valid tools and still leave the model choosing the wrong action, missing relevant context or struggling through an interaction that the protocol could support more directly. Harald Kirschner approaches that problem from his work on VS Code and local development, with lessons that apply beyond the IDE.

The ecosystem in this recording is still forming its working practices. Kirschner describes its first in-person MCP steering committee gathering as having happened ten days earlier, after collaboration largely through Discord. The missing pieces are opportunities for implementation and feedback, rather than evidence that the specification has failed.

MCP already includes **roots, sampling, prompts, tools and resources**. Together, these support dynamic discovery, persistent resources and richer interactions. Yet the fastest path to a useful product is often to wrap an API in tools. Successful products establish examples that other developers copy, reinforcing a tools-only ecosystem. Missing support in clients, SDKs, documentation and reference implementations makes that choice harder to escape.

![Slide with three columns titled Pragmatic shortcuts, Self-reinforcing loop, and Technical barriers beneath “Just another API wrapper” syndrome.](https://ai.engineer/api/talk-essay-media/ed06ac248680a09e0eb9dd459bad94cbd28f41539d33abcc019fcadba028590e)

“Just another API wrapper” syndrome: pragmatic shortcuts, a self-reinforcing loop, and technical barriers.

Tools can approximate some prompt and resource workflows, so starting there is understandable. VS Code did the same: its initial MCP implementation concentrated on tools, with discovery and roots already included. Kirschner then announces broader specification support in Insiders and an upcoming release, documented in the [VS Code 1.101 release notes](https://code.visualstudio.com/updates/v1_101). This is the historical implementation context of the demonstrations; experimental sampling and later draft additions should not be read as a claim that every future capability was already shipped. The goal is **richer, stateful interactions**, not merely a larger inventory of callable functions.

### Give the model the tools it needs now

[3:25](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=205s)

**Tools represent actions** and map naturally to function calling. In the Playwright example, a server opens a browser and takes a screenshot. But adding more tools does not automatically improve the model’s ability to complete a task: the IDE may reject the inventory, or the model may select an inappropriate action.

Kirschner points to LangChain research on three sources of difficulty: tool count, the diversity of domains and instructions, and repeated tool-use steps. [Benchmarking Single Agent Performance](https://www.langchain.com/blog/react-agent-benchmarking) examines these pressures in a particular ReAct assistant, rather than establishing a universal tool-count limit. A focused UI-testing tool set gives the model a more coherent task environment than a mixture of unrelated actions, properties and instructions. Longer sequences also give it more opportunities to lose track of the task.

VS Code exposes several ways to narrow or direct tool use:

| Control | What it changes |
|---|---|
| Per-chat tool picker | Limits the tools available in the current session |
| Explicit tool mentions | Names the intended action while the model supplies parameters |
| User-defined tool sets | Saves a reusable selection, such as front-end testing tools |

The picker supports keyboard interaction and preserves the selection for the session. Tool sets make the same decision reusable: once the relevant testing tools are identified, the user can invoke that collection without rebuilding it for every conversation. These controls put quality of selection ahead of quantity of exposure.

![Tools: User controls slide with three screenshots showing per-chat tool selection, mentioning tools in prompts, and user-defined tool sets.](https://ai.engineer/api/talk-essay-media/8be2d1e69afb2716f5773fb1c1777a5605b54a1a58a259dd32bcfbafc5e6a3c9)

VS Code tool controls: per-chat selection, tool mentions, and user-defined tool sets.

### Make available actions follow the game state

[5:20](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=320s)

Manual selection is only one way to control the tool inventory. **Dynamic discovery** lets the server change the tools it exposes while an interaction is underway. In the dungeon crawler demonstration, a custom chat mode gives the agent a game-master prompt. The user switches to the MUD mode and begins playing; the server adapts the available actions to the current room.

The player can move between rooms, travel east or north, and pick up items. Fighting makes sense only when a monster is present, so the battle tool should be absent in an empty room. When the player eventually encounters a goblin, the battle tool appears. Availability expresses the game’s current state instead of requiring the model to infer that an always-visible action is temporarily invalid.

The selection rule can be expressed directly in Python. This small example isolates the inventory decision: entering the goblin encounter exposes `battle`; it does not execute a battle.

```python
from dataclasses import dataclass

@dataclass(frozen=True)
class Room:
    exits: tuple[str, ...]
    items: tuple[str, ...] = ()
    monster: str | None = None

def available_tools(room: Room) -> list[str]:
    tools = []
    if room.exits:
        tools.append("move")
    if room.items:
        tools.append("pick_up")
    if room.monster is not None:
        tools.append("battle")
    return tools

empty_room = Room(exits=("east", "north"))
goblin_room = Room(exits=("east", "north"), monster="goblin")

assert available_tools(empty_room) == ["move"]
assert available_tools(goblin_room) == ["move", "battle"]
```

The MCP integration must expose the changed inventory through discovery so the client can make the new action available to the model. The useful boundary is between an action becoming possible and the agent choosing to perform it.

### Expose artifacts and understand the workspace

[6:31](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=391s)

An action may produce context without needing to place all of it in the immediate tool response. Instead of returning a giant file, a server can return a reference that the model follows when needed or that the user acts on directly. Resource links in tool results were still prospective here and subsequently appeared in the [June 2025 specification revision](https://modelcontextprotocol.io/specification/2025-06-18/changelog).

**Resources give artifacts meaning beyond a text response.** A screenshot captured through Playwright should be accessible to both the model and the user. Treating it as a resource preserves that shared role: the artifact is something to inspect or use, rather than merely content buried inside an action’s output.

A development server can also adapt to information already present in the workspace. It can inspect the Python environment and settings, then use installed packages and libraries to distinguish a React project from a Svelte project. This avoids repeatedly asking the user to identify a framework that the project itself reveals. Reading CI/CD configuration extends the same approach through the delivery pipeline, connecting local development with the rest of the workflow.

### Request model work through the client

[7:45](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=465s)

**Sampling** lets an MCP server request an LLM completion from the client. The [sampling specification](https://modelcontextprotocol.io/specification/2025-03-26/client/sampling) calls this operation `sampling/createMessage`. “From the client” identifies who mediates access; it does not require the model to run locally. In the demonstration, VS Code displays a permission dialog before allowing the server to access the model. Kirschner identifies **GPT-4.1** as that implementation’s default, not a protocol requirement. The client retains control over model selection and permissions.

Structured formatting for sampling is described as further specification work. That distinction matters because a server requesting a completion still needs to handle the response format its client supports; later structured tool output is a separate capability.

Sampling provides a natural path to **progressive enhancement**:

- **Summarize resources:** turn a large resource into a more focused representation instead of always returning everything.
- **Prepare fetched content:** convert a website into Markdown suitable for the model’s next step.
- **Run agentic server tools:** let a server’s workflow request model work through the client.

The server can supply useful content without sampling, then perform additional processing when the client supports it. This makes model access an enhancement to the interaction rather than an assumption hidden inside every tool.

### Keep both sides of the connection current

[8:53](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=533s)

The dungeon’s changing tool set is one instance of a broader pattern. Roots, resources, tools and prompts participate in an interaction whose context can change after the connection begins.

| Origin | What changes |
|---|---|
| Client | Workspace roots as the VS Code workspace changes |
| Server | Available resources, tools and prompts as server state changes |

Discovery therefore needs to be treated as an ongoing exchange, not just an initial inventory. The client keeps the server informed about the workspace, while the server keeps the client informed about what it can currently provide.

### Debug the process the host launches

[9:25](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=565s)

Richer server behavior also needs a workable development loop. VS Code provides an MCP server console for diagnostic output, then adds a development-mode toggle that enables debugger attachment. In the demonstration, invoking a prompt generated by the server reaches a breakpoint in its implementation.

![VS Code beneath Better DevX: Dev mode, showing a Python welcome function, a red breakpoint marker, and chat output listing the current TTS engine and available tools.](https://ai.engineer/api/talk-essay-media/4a8ee86e9b2f65b06dbd86fa38c63af74d4b012c3c92b57207d43435e40f46bf)

The Chatterbox welcome prompt’s Python source alongside its output in Copilot chat.

The difficulty is process ownership: an MCP server is often launched by its client or host, rather than by a command the developer starts manually under a debugger. VS Code occupies both roles, so it can launch the server and attach its debugger. The historical automatic debugging support covers Node.js and Python servers launched with `node` and `python`, respectively.

That turns debugging into a direct loop:

1. Enable development mode for the server.
2. Set a breakpoint in the server implementation.
3. Invoke the server-generated prompt from chat.
4. Step through the handler and inspect its state.

The important improvement is that the interaction being debugged comes from the actual MCP host, rather than requiring a separate manual reproduction of the server call.

### Exercise authorization and transport before they harden

[10:28](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=628s)

Draft specifications need implementation feedback before they become stable. Otherwise, a feature can advance without enough real use to expose its problems, leaving a later revision to repair them. Kirschner uses authorization as the example and characterizes its update as enabling enterprise-grade authorization. He points to Ben’s protected-server session for a deeper discussion.

Transport support has a similar dependency on adoption. Kirschner says VS Code had supported **Streamable HTTP** for two releases, but the small number of hosted servers using it made interoperability difficult to test. His recommendation to hosting providers is to move from the older HTTP+SSE transport to Streamable HTTP.

This is not a recommendation to abandon SSE itself. The [Streamable HTTP transport specification](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports) retains optional SSE streaming and permits stateful sessions. The distinction is between the older transport arrangement and the newer HTTP-based one, not between streaming and non-streaming, or stateful and inherently stateless servers. Kirschner’s stated operational benefit is avoiding the older arrangement’s stateful server churn.

### Help users find servers and supply missing information

[11:40](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=700s)

Discovery also has a meaning outside an active connection: how does a user find a server in the first place? Passing configuration JSON blobs from developer to user is a cumbersome distribution mechanism. The community [MCP Registry](https://github.com/modelcontextprotocol/registry) is presented as public work toward making servers easier to discover. This complements dynamic capability discovery: one helps users find a server; the other helps a connected client understand what that server currently offers.

Once a tool is running, another gap can appear: the model has supplied arguments, but the workflow still needs concrete information from the user. **Elicitation**, presented here as an upcoming draft capability and later included in the June revision, lets the server reach back for that information. Instead of sending the user into another chat experience, the client can offer a direct input interaction. The tool workflow can then continue with information supplied by the person who actually knows it.

### Make richer implementations useful enough to spread

[12:46](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=766s)

Progressive enhancement gives server authors a way to build beyond tools without waiting for every client to catch up. Implement richer behavior in clients that support the relevant capabilities, test it with real users, and publish examples that show why stateful interactions are useful. Reference servers and shared practices can turn isolated implementations into patterns other developers can adopt. As users demonstrate those benefits, they create demand for missing client support.

The design target is an action-oriented server that understands context and exposes meaningful artifacts. Contributing to that target includes reading open proposals such as namespaces and search, following the corresponding SDK issues, and reporting implementation experience. Kirschner emphasizes that this feedback has practical influence: the VS Code team reads incoming MCP issues and uses them to shape its roadmap.

![Help Needed: Rich and Stateful Servers slide calling for progressive enhancement, sharing best practices, filing client and SDK issues, and staying current with the spec.](https://ai.engineer/api/talk-essay-media/bbd3624f585d95c06db03d5cf8935c24e660ab2112207068e3211de6c58bae22)

Rich and stateful servers: close the implementation gap and contribute to the ecosystem.

Sampling is his final example of a capability worth asking clients to support. The remaining work is not only to extend the specification, but to make its existing capabilities usable across implementations. A server that demonstrates a better interaction—and supplies concrete feedback when a client cannot support it—helps close that gap.

## Resources

- [VS Code 1.101 release notes](https://code.visualstudio.com/updates/v1_101) — Historical release documentation for MCP prompts, resources, experimental sampling, tool sets and server debugging.
- [MUD-MCP](https://github.com/Nexlen/mud-mcp) — A dungeon game server illustrating tools that appear as game state changes, alongside resources, prompts and sampling.
- [Benchmarking Single Agent Performance](https://www.langchain.com/blog/react-agent-benchmarking) — LangChain's experiments on how additional tools and instructions affect a ReAct assistant's calendar and customer-support tasks.
- [Historical MCP sampling specification](https://modelcontextprotocol.io/specification/2025-03-26/client/sampling) — The March 2025 protocol contract for servers requesting model generations through clients, including permissions and model preferences.
- [Historical MCP transport specification](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports) — Streamable HTTP's request flow, optional SSE streaming and session management in the March 2025 specification.
- [MCP June 2025 specification changes](https://modelcontextprotocol.io/specification/2025-06-18/changelog) — The subsequent specification revision adding elicitation, resource links, structured tool output and revised authorization requirements.
- [MCP Registry](https://github.com/modelcontextprotocol/registry) — The community registry project for publishing and discovering MCP servers.

## Slides

### MCP ecosystem and remaining work

Kirschner points to the MCP steering committee’s first in-person gathering, 10 days earlier, as a sign that the fast-growing ecosystem is still early and has much work ahead.

[0:58](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=58s) [Track introduction highlights remaining work and the first in-person MCP steering committee gathering.](https://assets.ai.engineer/sites/aiecode2025/sha256/b14d21e75f9d8804c771e282ed428c27ab92b00f2df4fe89e6299ebf9957c21d.webp)

The winner of the 2023-2025 "agent open standard" wars has conquered the ecosystem — every client from Anysphere to Zed, and every lab from OpenAI to Google DeepMind. But there is much work left to do. The world's first dedicated MCP miniconf, ft. special double presentations by the MCP team from Anthropic, discussions on the new Auth spec, and the first IRL gathering of the MCP steering committee.

https://www.ai.engineer/#tracks

AIE
Microsoft
aws
smol ai

Interface text:
AI Engineer World's Fair
daily
SENTRY

### MCP’s basic primitives

MCP connects client-side roots and sampling with server-side prompts, tools, and resources through dynamic discovery. Kirschner says these primitives support rich interactions, but implementation still has gaps.

[1:24](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=84s) [Diagram connects client roots and sampling with server prompts, tools, and resources through dynamic discovery.](https://assets.ai.engineer/sites/aiecode2025/sha256/fd7620fc3c6cdb1f553e48785ce99e52d19a4694ed0a8e38d3f532508a37e787.webp)

MCP’s Basic Primitives

Client
Roots
Sampling

Dynamic Discovery

Server
Prompts
Tools
Resources

AIE
AI Engineer World’s Fair
Graphite
Weights [illegible]
Microsoft
aws
smol ai

### Just another API wrapper syndrome

Developers ship with tools, newcomers copy those patterns, and gaps in clients, SDKs and documentation reinforce the tools-only ecosystem.

[1:48](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=108s) [Three factors behind tools-first adoption: pragmatic shortcuts, a self-reinforcing loop, and technical barriers.](https://assets.ai.engineer/sites/aiecode2025/sha256/e130c29ec54b0a8144e75cdfcbe8b6f3a541a726a76e8afb736834afa4a3faa0.webp)

"Just another API wrapper" syndrome.

But why tools drove early adoption …

Pragmatic shortcuts
Developers stay within well-supported bounds to ship products

Self-reinforcing loop
Newcomers see the minimal patterns and copy it

Technical barriers
Early limitations in SDKs, clients, docs and references.

AIE
Microsoft
aws
smol ai

Interface text:
AI Engineer World's Fair
Graphite
Weights

### Early tools-first client adoption

In the MCP client list, 49 clients fully support tools, versus 18 each for resources and prompts. Discovery, sampling and roots trail further. VS Code’s starred features are in Insiders v1.101.

[2:35](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=155s) [Bar chart compares client support for tools, resources, prompts, discovery, sampling and roots, with VS Code support annotations.](https://assets.ai.engineer/sites/aiecode2025/sha256/c14257b7d59f448600bd89ca7c514e04cf4e86cc98db6b2d1e93033641d0fcdb.webp)

Early tools-first client adoption
How lacking feature support limits servers

X-axis ticks: 0, 20, 40
Tools: 49 ✅ VS Code
Resources: 18 ✅ VS Code*
Prompts: 18 ✅ VS Code*
Discovery: 7 ✅ VS Code
Sampling: 4 ✅ VS Code*
Roots: 3 ✅ VS Code

https://modelcontextprotocol.io/clients
Full only, excludes partial, or status not specified, or no support
VS Code*: Insiders v1.101, release June 11

### Full MCP spec and stateful interactions

Kirschner argues that full MCP spec support can unlock rich, stateful interactions between agents.

[3:14](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=194s) [Slide equates the full MCP specification with rich stateful interactions.](https://assets.ai.engineer/sites/aiecode2025/sha256/8f8a49a0ba7395a2c8161e0dde2893c0426d1fe59f6776d91c8596f8d720eaac.webp)

Full MCP Spec
≈
Rich stateful interactions

AIE
Microsoft
aws
smol ai

Interface text:
AI Engineer World's Fair
Graphite
Weights
baz

### Tools

Tools let LLMs perform actions through function calls. In the Copilot example, a development server starts, then Playwright navigates to the website and takes a screenshot.

[3:23](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=203s) [Slide describes tools as functions that perform actions and shows a Copilot example running a website and taking a screenshot.](https://assets.ai.engineer/sites/aiecode2025/sha256/76295db2bf724242fb59c363f8f0d3c60387e848f7061bdcf922d4d540d41aaf.webp)

Tools
The popular basic primitive

Functions that LLMs can call to perform specific actions - basically function calling.

• Send email
• Update todos
• Run tests
• File issue bug

Interface text:
Run the website and take a screenshot
GitHub Copilot
Used 1 reference
I'll help you run the website and take a screenshot. Let me start the development server and then take a screenshot of the website.
Started npm: Next: Start Development Server
Now I'll wait a moment for the server to start up, then navigate to the website and take a screenshot.
Ran Navigate to a URL – Playwright (MCP Server)
Perfect! The website is running. Now let me take a screenshot of the page.
Ran Take a screenshot – Playwright (MCP Server)

AIE
AI Engineer World's Fair
Graphite
Weights
Microsoft
aws
smol ai

### Tools: User controls

VS Code lets users narrow tools per chat, name tools in prompts, and reuse task-specific tool sets. Kirschner says user-defined sets are shipping in Insiders.

[4:30](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=270s) [Slide presents per-chat tool selection, mentioning tools in prompts, and reusable user-defined tool sets.](https://assets.ai.engineer/sites/aiecode2025/sha256/cba9096c84c64cd99f71c9f31f66584cd968b2be4af895ae790c18eaa9becdc2.webp)

Tools: User controls
Provide user controls to fine-tune and improve tool calls

Per-chat tool selection
Manually reduce tools required to complete a specific task

Mention tools in prompts
Reduce the guessing and reference tools as needed.

User-defined tool sets
Re-use task-specific tools across tasks

Interface text:

Edit with Copilot
Select tools that are available to chat
63 Selected
OK
searchResults  The results from the search view
githubRepo  Searches a GitHub repository for relevant source code...
MCP Server: Figma
mcp_figma_get_code_for_node_or_selection  Generate UI code...
mcp_figma_get_image_for_node_or_selection  Generate an ima...
MCP Server: github
mcp_github_add_issue_comment  Add a comment to an existing...
mcp_github_create_branch  Create a new branch in a GitHub rep...
mcp_github_create_issue  Create a new issue in a GitHub reposit...
[illegible] workspace in agent mode
Sonnet 4

CHAT
CSS (landing.module.css). All Tailwind classes have been replace[illegible]
Search for files and context to add to your request
MCP Resources...
Screenshot Window
Source Control...
Problems...
Symbols...
Tools...
landing.module.css  src/app  recently opened
tailwind.config.ts
mcp.json  .vscode
Add Context...  mcp_github_create_issue
For anything we haven't implemented, #mcp_github_create_issue and assign to Copilot.
Agent  Claude Sonnet 4

[illegible]h.toolsets.jsonc
"research": {
    "tools": [
        "mcp_perplexity_perplexity_as[illegible]
        "fetch"
    ],
    "de[illegible]
    "ic[illegible]
},
"a11y_a[illegible]

Select tools that are available to chat
User Defined Tool Sets
research  Web-based research.
a11y_audit  Accessibility audits using Playwright
Built-In
editFiles  Edit files in your workspace
runNotebooks  Run notebook cells
runCommands  Run commands in the terminal

### Tools: Dynamic discovery

An MCP server can add or update tools on the fly. In the Copilot example, the agent enables a GitHub toolset before searching for highly engaged issues.

[5:24](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=324s) [Slide describing scope-based tool enabling, workflow sequencing, and progressive disclosure, alongside a Copilot example.](https://assets.ai.engineer/sites/aiecode2025/sha256/6df4321a4dfa5b790fe8320279171004784ed9ceb4e0d2b06baab2fcab813646.webp)

Optimize tools as needed

Tools: Dynamic discovery

Server can add new capabilities or update existing on the fly.

• Enable tools based on scope
• Workflow-driven tool sequencing
• Progressive disclosure

Check the top 25 most upvoted and most commented issues in the modelcontextprotocol/modelcontextprotocol repo (past 1 month) and summarize the key themes in a table

GitHub Copilot
Used 1 reference

I'll help you analyze the top issues in the modelcontextprotocol/modelcontextprotocol repository. First, let me enable the necessary GitHub tools and then search for the most upvoted and commented issues from the past month.

Ran Enable a toolset – github (MCP Server)

Now let me search for the most recent issues with high engagement. I'll search for issues from the past month and then analyze the top ones by upvotes and comments.

Ran Search issues – github (MCP Server)

Now let me search for issues sorted by comments to get the most discussed ones: [partially cut off]

Interface text:
AIE
AI Engineer World's Fair
[illegible]ellum
Microsoft
aws
smol ai

### MUD game master configuration

The MUD chat mode sets a game-master prompt and seven adventure tools. The speaker says dynamic discovery makes the agent aware of the current room.

[5:33](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=333s) [Editor showing a game master chat mode, its MUD tools, and dungeon adventure instructions.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb35fa396c470d21ade23e616725f0d113e60392e3295ce958d1d35aeace43ba.webp)

---
description: 'MUD Game Master'
tools: ['mcp_mud_inventory', 'mcp_mud_look', 'mcp_mud_move', 'mcp_mud_pick_up', 'mcp_mud_battle', 'mcp_mud_accept_quest', 'mcp_mud_open_chest']
---

Welcome to the MUD Adventure!

> You find yourself at the entrance of a mysterious dungeon. Your quest, should you choose to accept it, is to explore its depths, battle monsters, and discover ancient treasures.

You act as the game master, guiding the player through a text-based adventure.

Interface text:
.github/chatmodes — mud-mcp-playground
Chat
MUD.chatmode.md
Configure Tools...
Ln 2, Col 31 (30 selected)
Spaces: 4
Chat Mode

### Entering the dungeon

In the MUD game master mode, Copilot calls look and inventory, then describes the dungeon entrance, its north exit and a nearby torch. The player starts empty-handed.

[5:53](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=353s) [Copilot uses the MUD look and inventory tools and describes the dungeon entrance.](https://assets.ai.engineer/sites/aiecode2025/sha256/5e0e4cead322846c20523d206f55f5a69ab3a36b55f7c6b7f6672daf8643ad48.webp)

Let's play.

GitHub Copilot

Welcome, brave adventurer! Let me guide you through this mysterious dungeon. First, let me see where you currently are and what's around you.

Ran look – mud (MCP Server)

You stand at the entrance of a dark and foreboding dungeon. The air is thick with mystery and ancient secrets. A single torch flickers nearby, casting dancing shadows on the stone walls.

Current Location: Dungeon Entrance Available Exits: North Items Present: torch

Let me also check what you're currently carrying:

Ran inventory – mud (MCP Server)

You begin your adventure with empty hands and an empty pack. The torch nearby might

Interface text:
Add Context...
MUD Game Master
MUD
Claude Sonnet 4

### Exploring the dark hallway

Copilot moves into a hallway with a key and a quest. Kirschner explains that dynamic tool discovery adjusts actions to the room: battle should appear when a monster is present.

[6:02](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=362s) [A MUD move tool result describes a hallway with a key, exits, and a quest.](https://assets.ai.engineer/sites/aiecode2025/sha256/6ea88a84a53d5fdf903858058b3612d59642e87692c46bb9aeaf3aadc3969429.webp)

Now, let's venture north into the depths of the dungeon!

Ran move — mud (MCP Server)

Ah! Your torch illuminates a fascinating sight. You've entered a dark hallway where ancient tapestries line the walls, their faded colors depicting legendary battles of ages past. The flickering light reveals the stories of heroes and monsters locked in eternal combat.

Current Location: Dark Hallway
Available Exits: South (back to entrance), East (deeper into the dungeon)
Items Present: key
Special: There's a quest available here!

A key glints in the torchlight - this could be very useful for unlocking doors or treasure chests you might encounter. And there's a quest waiting for you here, which could guide your adventure and perhaps offer rewards.

What would you like to do next?

• Pick up the key
• Learn about the available quest
• Continue exploring east
• Or something else entirely?

The adventure deepens! What's your next move?

Interface text:
Add Context...
Pick up stuff, accept the quest and continue east
MUD
Claude Sonnet 4

### MUD demo: battle and available tools

The battle tool appears when the player encounters a goblin. Copilot runs it and reports victory; the tool picker also shows actions for inventory, looking, movement, and picking up items.

[6:21](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=381s) [Copilot runs the MUD battle tool and begins a victory response.](https://assets.ai.engineer/sites/aiecode2025/sha256/35713859a65b956157d7755a50f83bc2d52faef953d8491719243d2859ad1f66.webp)

To battle!

GitHub Copilot

FOR GLORY AND ADVENTURE!

You raise your torch high, its flames casting fierce shadows on the chamber walls, and steel yourself for combat! The Cave Goblin snarls and prepares to strike!

Ran battle – mud (MCP Server)

VICTORY!

With courage

Interface text:
Add Context...
MUD Game Master
MUD
Claude Sonnet 4

[6:27](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=387s) [A tool picker lists MUD server actions over a completed battle in Copilot chat.](https://assets.ai.engineer/sites/aiecode2025/sha256/dee2a3e5aec5cfad422dbb2d66a45e5947c0f3dba8e6819df6911cea636861f1.webp)

Ran battle – mud (MCP Server)

VICTORY!

With courage in yo[illegible]nse but brief -
your adventurer's [illegible] defeated!

The chamber falls [illegible]nes seeming to
glow with approva[illegible]

Now that the threa[illegible]y, and the path
north beckons wit[illegible]

What would you li[illegible]

• Collect that po[illegible]
• Examine the ru[illegible]
• Continue north [illegible] deeper
• Check your current inventory and status

Your first battle is won - the dungeon's secrets await!

Interface text:
Select tools that are available to chat
11 Selected
OK
runNotebooks  Run notebook cells
runCommands  Run commands in the terminal
search  Search and read files in your workspace
MCP Server: mud
mcp_mud_inventory  Check your inventory contents.
mcp_mud_look  Provides a description of your current surroundings.
mcp_mud_move  Moves you in the specified direction.
mcp_mud_pick_up  Pick up an item in the room.
MCP Server: gistpad
mcp_gistpad_add_gist_comment  Add a comment to a gist
mcp_gistpad_add_gist_file  Add a new file to a gist
Add Context...
MUD Game Master
MUD
Claude Sonnet 4

### Resources

MCP resources expose read-only data through URIs. A server can return a reference to a file for the model to follow or the user to act on, instead of returning the entire file.

[6:33](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=393s) [Resources expose read-only data through URIs, including files, documents, database entries and images.](https://assets.ai.engineer/sites/aiecode2025/sha256/339294b9dfc9250e4903d94f1835e35637035a4fc9f3a7a1db063486a851a5e5.webp)

Ease of adding and returning data

Resources

Expose data in a read-only fashion as URIs client/agent/user.

• Files
• Documents
• Database entries/schemas
• Images

Interface text:
CHAT
Select MCP Resource...
Repository Content — github
Resource template: repo://{owner}/{repo}/contents/{/...
Repository Content for specific branch
Resource template: repo://{owner}/{repo}/refs/heads/{bran...
Repository Content for specific commit
Resource template: repo://{owner}/{repo}/sha/{sha}/conten...
Repository Content for specific pull request
Resource template: repo://{owner}/{repo}/refs/pull/{prNum...
Add Context...
contents
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4

AIE
AI Engineer World's Fair
daily
Microsoft
aws
smol ai

### Resources: Use cases

Resources can return references instead of large responses, expose files such as Playwright screenshots to users, and attach specific data as context to reduce tool lookups.

[6:36](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=396s) [Three examples show resources reducing response tokens, exposing files to users and attaching context.](https://assets.ai.engineer/sites/aiecode2025/sha256/08807f580cbfe464a648f530fd608a34956aa937e64dd874abdf955e470c72ec.webp)

Resources: Use cases
Make data accessible to clients and users

Reduce response tokens
Returning embedded resources lets the agent pull the data.

Expose data/files to user
Provide to assets for the user to act on, not LLM context.

Attach as context
Reducing tool lookups with specific resources attached.

Interface text:
Starting audio playback... – chatterbox (MCP Server)
Input
{
  "text": "Code whispers softly... Python dreams in workspace light... June voices awakening.",
  "cfg_weight": 0.3,
  "exaggeration": 0.6
}
Output
type-text-text-python-dreams-awakening-annotations-none

Ran Take a screenshot – Playwright (MCP Serve[illegible]
Input
{
  "filename": "homepage-screenshot.png"
}
Output
file.bin
- Ran Playwright code:
// Screenshot viewport and save it as [illegible]

Select MCP Resource...
get_audio_file  Get an audio file by its reso...  chatterbox
Resource template: chatterbox://audio/{re...
get_model_info  Get information about the TTS system.
chatterbox://model-info
get_audio_files_list  Get a list of all audio files as a reso...
chatterbox://audio-files
Comments for a gist  List of comments on a sp...  gistpad
Resource template: gist://{gistId}/comments
Add Context...
Agent  Claude Sonnet 4

### Roots: Use cases

Roots give tools context from the current environment: shared settings and secrets, project dependencies for framework-specific tooling, and infrastructure files for deployment tools.

[7:34](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=454s) [Three examples show environment access, framework-aware tooling and deployment activation.](https://assets.ai.engineer/sites/aiecode2025/sha256/223561343bf77a4ad3b306edbb2d3846560dc2d89d5afda68d305d5026552de6.webp)

Roots: Use cases
Access and dynamic context for the current environment.

.env
.venv
/mnt/secrets
.vscode/settings.json
…

Shared env/secrets access
Integrate with existing development environment.

cat package.json
cat pyproject.toml

Framework-aware tooling
Detect React project → surface React-specific testing tools.

cat devcontainer.json
cat deploy.yml

Deployment activation
Enable CI/CD tools only when infrastructure files are present.

### Sampling

Sampling lets an MCP server request an LLM completion from the client. The permission dialog shows the client asking before allowing access; examples include summarizing resources and building agentic server tools.

[7:51](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=471s) [Sampling lets servers request language model completions from the client; examples include summarization, extraction and agentic tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/109702c5b6177f2556d8e1740b17e60f57df11fbc613b81aab039ad86b65955c.webp)

The most exciting but least implemented primitive
Sampling

Servers can request a LLM completion from the client.

• Summarize resources
• Categorize and extract data
• Agentic server tools

Interface text:
The MCP server "chatterbox" has issued a request to make an language model call. Do you want to allow it to make requests during chat?
Allow in this Session
Always
Now Now
Never
Edit files in your workspace in agent mode

AIE
AI Engineer World's Fair
Graphite
Microsoft
aws
smol ai

[7:57](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=477s) [Sampling lets servers request language model completions from clients, with examples and a permission dialog.](https://assets.ai.engineer/sites/aiecode2025/sha256/f8a391ef4e318d1b04cf74c9638280dbf8b8d0329f22c70be0406d20e020b815.webp)

The most exciting but least implemented primitive
Sampling

Servers can request a LLM completion from the client.

• Summarize resources
• Categorize and extract data
• Agentic server tools

Interface text:
The MCP server "chatterbox" has issued a request to make an language model call. Do you want to allow it to make requests during chat?
Allow in this Session
Always
Now Now
Never
Edit files in your workspace in agent mode

AIE
AI Engineer World's Fair
Graphite
Weights
Microsoft
aws
smol ai

### Beyond the primitives

Kirschner moves beyond MCP primitives, noting that dynamic discovery lets clients update roots and servers update resources, tools and prompts as they change.

[8:51](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=531s) [Section divider titled Beyond the primitives.](https://assets.ai.engineer/sites/aiecode2025/sha256/ca3f9e558ef137df84bac6917f4db4392e67c04ea1bbaa435953c485a28189d8.webp)

Beyond the primitives

AIE
AI Engineer World’s Fair
Graphite
Microsoft
aws
smol ai

### Better DevX: Dev mode

The Chatterbox server configuration watches Python files and specifies debugpy. Kirschner attaches a debugger so he can step through a server-generated prompt.

[9:38](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=578s) [VS Code server configuration showing development-mode watch and debug settings.](https://assets.ai.engineer/sites/aiecode2025/sha256/11fde5479f64484de18ba0540f6f6d0001bf3fddcc0ed51344efa923cc5d3e5b.webp)

Better DevX: Dev mode

{
  "servers": {
    "chatterbox": {
      "command": "${workspaceFolder}/.venv/bin/python",
      "cwd": "${workspaceFolder}",
      "args": [
        "-m",
        "chatterbox_mcp_server"
      ],
      "dev": {
        "watch": "*.py",
        "debug": {
          "type": "debugpy"
        }
      }
    }
  }
[illegible]

AIE
AI Engineer World's Fair
vellum
Microsoft
aws
smol ai

Interface text:
mcp.json M
chatterbox_mcp_server.py M
Start | Debug | 2 cached tools
CHAT
Edit with Co[illegible]
Agent Mode
Ask Copilot to edit your files in a[illegible]
will automatically use multiple req[illegible]
edit, run terminal commands, an[illegible]
Copilot is powered by AI, so mis[illegible]
Review output carefully [illegible]
or type # to attach
Add Context...  mcp.json
Edit files in your workspace in age[illegible]
Agent  Claude Sonnet 4
Add Server...

### Debugging an MCP prompt

With the debugger attached, Kirschner runs the server-generated welcome prompt and can stop at a breakpoint to step through its Python code.

[10:00](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=600s) [VS Code shows a Chatterbox TTS welcome prompt alongside its generated message in chat.](https://assets.ai.engineer/sites/aiecode2025/sha256/5552bdd1267d752a5abb044aefbb207cab7a72a21046fb0b858b9295e4417855.webp)

@mcp.prompt()
def welcome() -> str:
    """A welcome prompt for the Chatterbox TTS server."""
    engine_info: str = f"Current TTS engine: {_tts_engine.upper()}"
    if _tts_engine == "say":
        engine_info += f" ({'✅ Available' if
        _check_say_availability() else '❌ Not available'})"

    return f"""Welcome to Chatterbox TTS! 🎤

{engine_info}

Available tools:
- Tool: 'speak_text' - Generate and play speech from text
- Tool: 'list_audio_resources' - View all generated audio files

Available resources:
- Resource: 'chatterbox://model-info' - TTS system information
- Resource: [illegible]

Chat prompt:
Welcome to Chatterbox TTS! 🎤

Current TTS engine: CHATTERBOX

Available tools:
- Tool: 'speak_text' - Generate and play speech from text
- Tool: 'list_audio_resources' - View all generated audio files

Available resources:
- Resource: 'chatterbox://model-info' - TTS [illegible]

Interface text:
chatterbox-mcp
mcp.json M
chatterbox_mcp_server.py M
CHAT
Agent Mode
Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.
Copilot is powered by AI, so mistakes are possible. Review output carefully before use.
Add Context... chatterbox_mcp_server.py
Agent  Claude Sonnet 4
main*  0  0
Not Committed Yet
Ln 761, Col 1
Spaces: 4
Python
3.12.10 (.venv)

### Spec: Latest & Upcoming

Streamable HTTP is marked stable, while updated authorization is in draft. The slide also previews a registry for discovery and elicitation for user consent; Kirschner urges feedback on drafts before they become stable.

[10:25](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=625s) [A specification overview lists streamable HTTP, updated authorization, a community registry, and elicitation.](https://assets.ai.engineer/sites/aiecode2025/sha256/1ffd05ec8d3985cef330673fffdfd32030f2d70855970ae6ccfa2fbe3c9a2ede.webp)

Evolving the spec

Spec: Latest & Upcoming

Stable: Streamable HTTP ✅
Enterprise-grade authorization and scaling

Draft: Updated auth ✅
Enterprise-grade authorization. Support for identity providers
Building Protected MCP Servers
Nobhill C&D, Thu 12:45 pm - 1:05 pm

Community registry
Solve discovery and installation, with a spec for public and private registries
github.com/modelcontextprotocol/registry

Elicitation
Explicit user feedback and consent
[mcp].io/specification/draft/client/elicitation

### Help Needed: Rich and Stateful Servers

Kirschner calls on developers to enhance MCP servers and share best practices and feedback, helping clients and SDKs catch up with the spec.

[12:43](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=763s) [Call to action to enhance servers and contribute best practices and feedback to the ecosystem.](https://assets.ai.engineer/sites/aiecode2025/sha256/0e9c8f19e48226387a68f5ccce7f984c226ae37ed12766b248aff27ca4fba568.webp)

Call to Action!

Help Needed: Rich and Stateful Servers

Close the implementation gap
Progressively enhance your servers to be action-oriented, context-aware and semantic-aware

Contribute to the ecosystem
Share your best practices, file issues for clients and SDKs, stay up-to-date on the spec

AIE
Microsoft
aws
smol ai

Interface text:
vellum
AI Engineer World's Fair

## Full transcript

[0:00](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=0s) [upbeat music] Since all the questions already got asked, who built an MCP server and it didn't work?

[0:23](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=23s) Okay, Sam, go. [laughs] So we're here to comm-commiserate on, like, how to actually build with the full spec, what are the hidden capabilities, why they matter, and how they light up.

[0:32](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=32s) I work on VS Code, so this is a biased local MCP for development track, but all of it is applicable to everything. I really love the intro to the track.

[0:44](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=44s) It's all about... It's MCPs on high velocity. It's a lot of ecosystem growth, excitement, people working together, collaborating. But there's so much more work to do as they realize it's so early in that ecosystem.

[0:58](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=58s) So none of this is a criticism of the spec or the ecosystem. It's just we're so early, and I want to point out where we can gain more powers.

[1:06](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=66s) And just 10 days ago, on a Friday, we had actually the first l- in real life gathering of the MCP steering committee during the MCP Dev Summit. So that's how early it is.

[1:16](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=76s) We haven't even met before. We just talk on Discord. So we finally met in person the first time to talk about the... anything, how to evolve the spec, how to evolve the ecosystem.

[1:26](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=86s) And all the basics are kinda covered, um, hopefully in the previous talks. This is my first MCP talk that I don't spend halfway through just explaining what MCP is.

[1:35](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=95s) There's roots in the client. There's sampling. There's prompts and tools and resources. There's a really rich ecosystem to build dynamic discovery and persistent resources and rich interactions. But there's a gap in how this is being implemented.

[1:50](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=110s) There's this, like, MCP's just another API wrapper syndrome that's happening because people just wanna ship. They wanna build products, and they're actually building really excellent products with just tools.

[2:02](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=122s) And that creates this reinforcing loop because once you see how MCP works, you're just gonna use the same stacks and repeat the same tools only ecosystem. And there's technical barriers.

[2:11](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=131s) People do this because there's missing support in the clients and SDKs and documentation and the references.

[2:19](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=139s) And the clients reflect this most. If you look at the adoption that's from the website of Model Context Protocol, you see everybody goes for tools 'cause that's where the most immediate success is.

[2:29](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=149s) And if you're honest, actually most of, like, resources and prompts, you can do similar flows just with tools. And VS Code did the same thing. We-- When we launched two weeks-- two months ago now with our MCP support, we started with tools, and we already added discovery and roots because we were working towards actually reading the s-

[2:48](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=168s) the spec and implementing it. And I'm happy to announce that with VS Code's upcoming release, V one points one zero... [laughs] Gonna get it wrong. But it's already in Insiders now, so download it.

[3:00](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=180s) We actually have the full spec support, and that's-- I wanna talk about here, about all the other things that people are not using yet.

[3:08](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=188s) Whoo, whoo.

[3:08](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=188s) Yes, let's hear them clapping. [audience applauding] [laughs] Okay, so the message is if you go with full MCP spec support, you will-- can unlock these rich, stateful interactions that MCP's vision is really outlining on how agents should work together.

[3:25](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=205s) Starting with the most obvious, tools. So not getting too deep here, but tools reflect actions, well-defined performing actions and mostly easy mapping to function calling if you're used to that.

[3:37](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=217s) And on the right side, you see Playwright. You can start a server. It will open the browser and take a screenshot. But tools are often leading to quality problems, and we all struggle with that.

[3:46](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=226s) Raise your hand if you had, like, some error in your IDE that, that you couldn't add more tools and you couldn't run it or it run wrong tools because you had too many.

[3:55](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=235s) And there's research from LangChain that nicely underlines that and pointing out the three vectors of, A, it's too many tools. So AI gets confused by that. It's too many domains of tools.

[4:05](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=245s) So if you suddenly have some different properties for each tool and instructions coming with each tool, then it also gets confused versus just a pure, like, this is UI testing.

[4:15](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=255s) And lastly, it's, uh, just the repetition. The more repetitions of the A-AI has to do to actually run tools to solve a problem, the easier just it is to get confused as well.

[4:25](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=265s) So it's really quality over quantity. And clients handle that somewhat. They give you extra controls. Like in VS Code, uh, we added actually per chat tool selection. So there's a little tool picker, and you can actually reduce down the tools of what you actually need in the moment versus all the tools.

[4:44](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=284s) It has nice keyboard accessibility. It's really quick to set up and will persist for the session. So that's one way. We have actually mentioning of tools. Like, sometimes you, like, pull this issue and trying to, like, verb out whatever tool you're trying to in-invoke.

[4:57](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=297s) Like, why not just use this tool and please make up all the right parameters to use it properly and then use the other tool? So that's what we allow as well.

[5:04](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=304s) And then lastly, just in this Insiders actually, we're shipping user-defined tool sets, and that's more of a u- reusable concept. Once you get into the mode, like, these are all the tools I need for a front-end testing flow, then you just put those into a tool set and then use my front-end testing flow.

[5:20](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=320s) So that's coming as well. So these are all user controls, but actually that spec has dynamic discovery built in. And that means on the fly a server can say...

[5:29](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=329s) But actually that spec hack are gonna give you these other tools. And on the right, you see GitHub modmcp. It's on GitHub. You can check it out. And this starts with a chat mode that I created that puts the agent into a game master prompt, and it has the modmcp installed.

[5:45](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=345s) So now with the mode active, I can go into the agent, switch to MUD, and play the game. And what dynamic tool discovery does here, it actually makes it aware of which room I am in.

[5:57](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=357s) So dungeon crawler, you walk from room to room. Like, you can go east and north. You can pick up stuff. And if there's a monster, I can battle the monster.

[6:04](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=364s) But the tool for battling shouldn't be there when there's no monster.

[6:18](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=378s) Eventually, I advance through the game, and I finally find a goblin I can battle, and the battle tool appears. I can battle the goblin. So imagine those, those MCP you wanna work on.

[6:31](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=391s) Those are coming up to give servers and clients a little bit more. Really, tools or actions, actually the add context don't return a giant file from your server, but you wanna return a reference to the file, and that could be something the LLM could follow up on or the user can actually act upon.

[6:47](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=407s) Then the other use case is actually giving files to the users. So if you take a screenshot via Playwright, you wanna expose it to both the LLM and the user, and resources provide that semantic layer.

[7:00](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=420s) And now you in. What are the issues? Oh, I found new issues. That's... They wanna understand the Python environment and maybe look at your settings of how you set it up so they can customize it.

[7:10](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=430s) And that makes it more dynamic and stateful out of the box.

[7:15](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=435s) The other one is, like if you can look at actual, the packages and your libraries installed, that's a great way to customize it to a React setup versus a Svelte setup, and really acknowledging what the user's looking at and not asking constantly like, "What framework are you working on?"

[7:28](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=448s) Like, just you, you work in my folder, so just look at it.

[7:33](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=453s) And lastly, I think the idea of like what, what is that CI/CD pipeline? That's where MCP servers really shine to connect the end to end of a developer experience, and you can also read those out.

[7:45](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=465s) Sampling. Who has heard about sampling? Is really excited about sampling. Okay, so you understand what I mean. So sampling, sampling is one of the oddly named, uh, primitives as well.

[7:56](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=476s) And if it had a better name, maybe more people would use it. Uh, but it's actually now in VS Code Insiders, and it's so much fun to use. So it allows the server to request LLM completions from the client.

[8:08](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=488s) What I'm showing here on the right is the permission dialog that pops up to allow the server to access the LLM. Right now, it's wired up by default to GPT-4.1.

[8:17](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=497s) There's more spec improvements to make it with structured formatting. There's some ideas out there. So there's a lot of things to make it better, but right now nobody has implemented it, so there wasn't really a need to make it better, but implementation's now here, so please use sampling.

[8:30](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=510s) That's a nice progressive enhancement. Maybe by default you return the kitchen sink, and once you have sampling, you can do interesting things like summarizing resources in, into more tangible things.

[8:41](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=521s) You can format a website that you fetch into markdown for the LLM, or you can even think about agentic server tools that w-one run via the LLM from the client.

[8:53](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=533s) If you look beyond the primitives, there's a few things that are also interesting. So far we have roots and tools and resources and prompts, and they-- with dynamic discovery, you can update them at any time.

[9:06](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=546s) The client will send new roots as the VS Code workspace changes. You can send new roots, uh, new resources, uh, new tools and prompts from the server as you update and you change.

[9:18](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=558s) So it's a really dynamic environment already. But there's more pain points to make these servers really powerful.

[9:25](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=565s) One is the developer experience. Who's been struggling with working on MCP servers and debugging and logging and everything? Yeah. One of the-- hands up. Yeah. There's some. Apparently it's really easy, so maybe it's not a problem. [laughs]

[9:39](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=579s) Okay, so we have a now dev mode in VS Code, which is a little dev toggle, and you already see the console that always works for all MCP servers.

[9:47](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=587s) So once you hit a snag, that just works. And then now, n-now it's in debugging mode, so it actually has the debugger attached. So once I run the prompt, which is dynamically generated on a server, I can now hit the breakpoint and step through it.

[10:02](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=602s) And that's really hard usually because your server is not owned usually by any process that you run manually. It's owned by whatever client and host is running the MCP server.

[10:13](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=613s) So because VS Code is both, it can just put it into debug mode and attach its debugger, and that works for Python and Node right now out of the box.

[10:22](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=622s) So super exciting. And it's, yeah, it has changed how I work on MCPs, definitely.

[10:28](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=628s) The latest spec, uh, was already called out. I just wanna call it out again because it's so important that people stay on the tip of the spec on what's coming and understand what's in draft.

[10:39](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=639s) Those things that are in draft only become stable because people provide feedback that it's useful and that it's working. And if they're in draft and nobody provides feedback, then they will still go into stable, and they might need revisions like the auth spec.

[10:53](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=653s) So the updated auth spec on the right gives this enterprise-grade authorization. There's a talk tomorrow about building protected MCP server that I can highly recommend from Ben who actually worked on the auth spec.

[11:05](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=665s) So if you wanna talk to one of the people behind it and wanna dive really deep into auth, you can do that. Then streamable HTTP has been working in VS Code since two versions as well, but then it's been really hard to test because there's no servers out there.

[11:21](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=681s) So if you work on hosting, you're really excited about streamable HTTP, you should really get everybody that is hosting MCP servers to, to get onto it and not use SSE anymore.

[11:31](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=691s) SSE is still possible to use with HTTP, so you get both benefits, but you're avoiding this really stateful churn on your servers.

[11:40](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=700s) Last one already mentioned, there's a community registry happening, and that's been the other big pain point. Like if I build a server and nobody finds it, or what is the discovery experience?

[11:48](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=708s) Like how do I send people? Like do I send JSON blobs around for people to discover my server? There's a lot of community work around this to make this discovery easy.

[11:57](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=717s) So it's a big shout-out to everybody on the steering committee, the community working groups, and everybody involved here. Um, if you wanna check it out, it's on modelcontextprotocol/registry on GitHub, and it's all happening out in the open.

[12:10](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=730s) And lastly, I'm really excited about elicitations. Um, that's actually coming in the next draft, um, spec reference. Spec, draft, release, whatever. [laughs] And this is a way for tools to finally reach out back to the user when they need more information.

[12:24](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=744s) Right now, tools are all controlled by the LM, and you get all the information from them. But then when it actually needs more concrete specific input from the user, then you, you can just throw them into another chat experience and ask for it, but why not just give them an input to provide it directly?

[12:39](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=759s) So it's, it's again, more statefulness in the tools on top.

[12:46](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=766s) So your help is needed. Um, progressive enhancement in MCP is possible. I think we wanna have more best practices out there, maybe even in the reference servers to show it off, but everything is now ready to be used.

[13:01](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=781s) There's clients supporting the latest spec that you can run it in and test it in. Those clients are used by users, and as more users showcase how great the stateful servers can be and outline these best practices, this interoperability gap will close and clients will catch up.

[13:19](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=799s) It's a very fast-moving ecosystem. People are complaining like, "Oh, you shipped this two weeks after the other person." [laughs] Um, but it's all coming together and as, as people use these and learn and bring feedback, it becomes better.

[13:31](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=811s) So make action-oriented, context-aware, semantic-aware servers using the full spec. And then lastly, contribute to the ecosystem. If you have the time, read up on some of the open RFCs I shared, like namespaces and search, to kinda see what's coming.

[13:49](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=829s) Make sure they get into the SDKs you're using by following the issues, and just share back on your experience. I think a lot of people mis- misunderstand how much influence they have on clients and SDKs and everything by filing issues, by providing feedback.

[14:05](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=845s) I'm helping to triage a lot of the MCP issues coming into VS Code. We read all of them, we learn from them, and really that drives our roadmap. And that happens probably with every other, uh, team out there.

[14:16](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=856s) So really make your voice heard of, like, you-- everybody should support sampling, so. So there's a transformative potential in MCP that we all can unlock with the spec that is already there, so the ecosystem catches up to the spec.

[14:31](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=871s) So with that, let's go. Um, and feel free to hit us up on the Microsoft booth. There's two VS Code people there, Tyler and Rob. You can also talk to, or talk to me, or talk to your friendly MCP steering committee members.

[14:46](https://www.youtube.com/watch?v=ExeD-8gFUMM&t=886s) Thank you. [outro music]
