Is MCP dead?

• With plain MCP, an agent loads every tool's definition into its context window before it does anything. For a big API, that is a lot of the model's memory spent on manuals.
• Code Mode turns those tools into a TypeScript API. Instead of calling tools one at a time, the agent writes a small program that calls them.
• The program runs in an isolated sandbox on Cloudflare. Results between steps stay in the sandbox, so they don't pass back through the model, and the code never sees API keys.
• Cloudflare's own MCP server now exposes just two tools, search() and execute(), for its whole API. That costs about 1,000 tokens instead of about 1.17 million: a 99.9% cut in input tokens.
• MCP isn't dead. It still connects, describes and authorises the tools. The agent simply uses it through code.

The Model Context Protocol (MCP) is an open standard for connecting AI agents to tools and data. A service such as GitHub, a database, email or a payments API runs an MCP server. The server lists its tools, and for each tool it gives a name, a description and the parameters it accepts. An agent that connects to the server can then call those tools.

Any service with an MCP server: one standard plug for all of them.

What a tool definition looks like

Every tool comes with a description written in JSON Schema. A single tool might look like this (simplified example):

{
  "name": "create_issue",
  "description": "Create a new issue in a GitHub repository",
  "inputSchema": {
    "type": "object",
    "properties": {
      "repo":  { "type": "string", "description": "owner/name" },
      "title": { "type": "string" },
      "body":  { "type": "string" }
    },
    "required": ["repo", "title"]
  }
}

How a normal tool call works

This works well for a handful of tools. The trouble starts when there are many tools, or a task needs many steps.

Problem 1: the context fills up before work starts

A model can only hold a limited amount of text at once, its context window, measured in tokens (roughly word pieces). Tool definitions are loaded up front, so every tool takes some of that space whether the task needs it or not.

Cloudflare's API has over 2,500 endpoints. Cloudflare measured an equivalent MCP server without Code Mode at about 1.17 million tokens, and estimates over 2 million if every endpoint were its own tool.

Problem 2: every step goes back through the model

With plain tool calling, each result comes back into the model's context. The model reads it, picks out what it needs, and writes the next tool call. A ten-step task means ten trips through the model, and each trip adds more tokens and more waiting.

Why it matters

• Cost: you pay for every input token, on every request.
• Speed: each round trip is another model call to wait for.
• Room to think: context spent on manuals and raw results is context the model can't use for the task itself.

Cloudflare introduced Code Mode in September 2025 as part of its Agents SDK. It works in four steps.

Step 1 in practice: from schema to TypeScript

The create_issue tool from section 2 becomes a typed function the model already knows how to use. Roughly (illustrative):

declare const codemode: {
  /** Create a new issue in a GitHub repository */
  create_issue(input: { repo: string; title: string; body?: string }): Promise<Issue>;
  /** List issues in a repository */
  list_issues(input: { repo: string; state?: "open" | "closed" }): Promise<Issue[]>;
};

Steps 2–4 in practice: one script instead of many calls

const issues = await codemode.list_issues({ repo: "acme/web", state: "open" });
const stale = issues.filter((i) => i.comments === 0);   // filtering happens here, not in the model
for (const i of stale) {
  await codemode.add_label({ repo: "acme/web", issue: i.number, label: "needs-triage" });
}
console.log(`Labelled ${stale.length} stale issues`);   // the only thing the model reads

The architecture

Calls from the sandbox are RPCs routed back to the agent loop, which dispatches them to the MCP servers.

In February 2026 Cloudflare applied Code Mode to its own MCP server, which covers the entire Cloudflare API. It exports only two tools. Each takes a single string of code: a JavaScript async arrow function.

async () => Object.entries(spec.paths)
  .filter(([path]) => path.includes("/dns_records"))
  .map(([path, ops]) => ({ path, methods: Object.keys(ops) }))

async () => {
  const zones = await cloudflare.request({ method: "GET", path: "/zones" });
  const zone = zones.result[0];
  const dns = await cloudflare.request({ method: "GET", path: `/zones/${zone.id}/dns_records` });
  return dns.result.map((r) => ({ type: r.type, name: r.name }));   // only this returns
}

Code samples in this document are illustrative. The server's own tool descriptions give the exact shape of spec and cloudflare.request().

The numbers, drawn to scale

The Code Mode bar is 0.09% of the other one; what you see is its minimum visible width. Cloudflare's 99.9% figure is measured against the 1.17M baseline, counted with tiktoken.