Anthropic's Code Execution Release Makes MCP Hubs Smarter

Anthropic just gave Model Context Protocol users the upgrade I’ve been waiting for: agents can now generate and run code against MCP servers, complete with persistent files and reusable “skills.” Instead of juggling dozens of tool schemas in-context, the agent treats tools like importable functions, pulls only what it needs, and filters the results before any of it hits the conversation. If you read my earlier post on why I built a three-tool MCP hub, you already know the pain this solves.

What Anthropic shipped

The new workflow lets an agent write a script that calls MCP tools as if they were filesystem resources. That script executes in a sandboxed environment, so loops, conditionals, and retries happen in code instead of across multiple LLM messages. Tool definitions become on-demand imports rather than manifest dumps, and the agent can stash intermediate data to disk or upgrade it into a named Skill for future runs. Most importantly, massive tool outputs can be filtered, aggregated, or tokenized before they ever touch the model’s context window.

Why this pairs perfectly with an MCP hub

My hub already funnels tool discovery through search_tools, describe_tool, and invoke_tool so agents only fetch schemas for the tools they actually use. Anthropic’s execution layer pushes that idea further by keeping tool chatter outside the LLM altogether. The hub remains the registry and permission gate, but now the heavy lifting happens in code: call search_tools, grab a schema, write a quick transform, and let the script return a tiny summary instead of a megabyte of JSON. Less context burned, more reasoning budget saved for the actual task.

Skills are the missing legos

The part I’m most excited about is the Skills concept. Once the agent writes a useful routine—say, reconcile GitHub issues with Notion docs—it can save that snippet and reuse it like any other tool. Combine that with the hub’s provider modules and you suddenly have a virtuous loop: new API integrations still register inside the hub, but the workflows evolve in code that’s shareable, reviewable, and versioned.

What to watch next

Running arbitrary code means we need better sandboxing, observability, and policy enforcement. Metrics from the hub become even more valuable when scripts can fan out across multiple providers. I’m already experimenting with semantic search inside search_tools so scripts can locate the right capability faster, plus per-agent allowlists so a rogue skill can’t nuke production data. Anthropic’s release proves MCP doesn’t have to be verbose or brittle—we just have to keep pushing tool discovery and execution into purpose-built layers.