Integrate Code Execution with MCP

[newsbubbles]

Description

On Nov 4th, Anthropic dropped a new paradigm... that I think we've all thought of as a valid approach or even tried at one point.... taking advantage of code for tasks/actions would be way more efficient than tool calling, but the problem is properly defining out the "library" of functions the agent could code with to perform the task, plus ... how to partition the input and output, when to allow the agent to assess the output of some function before choosing some next set of actions as code, etc.

Anthropic Blog: Code execution with MCP: building more efficient AI Agents

This solves it. I think the hybrid approach anthropic just introduced should be implemented into pydantic-ai right away. Their site includes examples and some more information about the exact standard, and this is fairly new.

It also reminds me of not just Skills, but early projects with minecraft agents where they coded their own skill sets and used that library to build skill sets that would let them beat the game. Code execution with MCP is a natural progression of all of this, and the question until now has been just how it fits into frameworks like MCP.

The frustrating part is that there's not really much information besides this blog post and an article talking about some team who has tried this, so I'm not sure how the exact implementation needs to be. I am willing to help with anything on this, just lmk

References

Anthropic Blog: Code execution with MCP: building more efficient AI Agents

[DouweM]

I haven't read the entire article yet, but this smells like Code Mode to me, and indeed (quoting from the article):

Cloudflare published similar findings, referring to code execution with MCP as “Code Mode." The core insight is the same: LLMs are adept at writing code and developers should take advantage of this strength to build agents that interact with MCP servers more efficiently.

We've been discussing supporting that for a little while already, and have 2 issues, 1 scheduled for later this month and one for December:

• Light-weight code mode: Let model chain tool calls #3093
• Code Mode: Tool Injection for mcp-run-python: Enable Python code to call back to agent tools with request/response flow #2037

(I assume the article covers some new ground as well; I'll read it when I get to working on this!)

[newsbubbles]

Before I found your agent framework, I used langchain, and out of frustration of that I started making my own agent frameworks. In one of them, the idea was that instead of tool calling I'd give them a module that they could have loaded into context (full hard typed python class with all it's functions), and then let the agent perform tasks with special instructions on how to use the class. It worked out fairly well, but lacked some of the conveniences of tool calling agents, like the whole (action -> genenerate -> action) flow built in.

The "class-in-context" method I used caused the agent to code some ephemeral function that would only be run once and then thrown away. It was superior to tool calling in the fact that it's decision graph was the code of the function itself. It wasn't too hard to get the code execution environment on the agent and put guardrails on it in multiple ways, and the biggest part about it was that it was super efficient.

Thinking about it after having used pydantic-ai and fastmcp for the last 6 months exclusively, I've come to see tool calling agents as some sort of superior case to a coding agent who writes one-off functions over some given set of methods in a class... simply because the LLM gets the chance to think about the tool response before it calls the next tool, and that is what differentiates the "code and run once" method I did with this other framework to what tool calling is in mcp servers and the like. BUT... and I think this is what makes the article shine... I also didn't read the whole article, but from what I can tell, Anthropic is basically proposing a hybrid standard in which the MCP Server is still defined in the same way, but the action of calling tools is split between actual tool calls, and coding up "ephemeral functions over those tools", for things like secure tasks (A very real situation when working with account credentials where you leak them through the context). In this case, this sort of hybrid tool calling and coding method really shines.

That is the part that most interested me, but the other part that was also pretty cool is this idea of the discoverability of tools only being like partial, and then somehow full details could be gotten about each tool separately in order to save on context taken up purely by tool definitions.