Code Mode - Bifrost

Overview

Code Mode is a transformative approach to using MCP that solves a critical problem at scale:

The Problem: When you connect 8-10 MCP servers (150+ tools), every single request includes all tool definitions in the context. The LLM spends most of its budget reading tool catalogs instead of doing actual work.

The Solution: Instead of exposing 150 tools directly, Code Mode exposes just four generic tools. The LLM uses those tools to write Python code (Starlark) that orchestrates everything else in a sandbox.

The Impact

Compare a workflow across 5 MCP servers with ~100 tools: Classic MCP Flow:

• 6 LLM turns
• 100 tools in context every turn (600 tool-definition tokens)
• All intermediate results flow through the model

Code Mode Flow:

• 3-4 LLM turns
• Only 4 tools + definitions on-demand
• Intermediate results processed in sandbox

Result: Up to 92.8% fewer input tokens, 92.2% lower estimated cost, and around 40% faster execution in large MCP deployments.

Benchmark Results

Bifrost Code Mode was benchmarked against classic MCP across three controlled rounds with increasing MCP footprint. Each round used the same query set with Code Mode off and on.

At around 500 tools, Code Mode reduced average input tokens per query by roughly 14x: from 1.15M tokens to 83K tokens. See the Bifrost MCP Gateway benchmark writeup, or explore the complete benchmark report.

Code Mode provides four meta-tools to the AI:

1. listToolFiles - Discover available MCP servers
2. readToolFile - Load Python stub signatures on-demand
3. getToolDocs - Get detailed documentation for a specific tool
4. executeToolCode - Execute Python code with full tool bindings

When to Use Code Mode

Enable Code Mode if you have:

• ✅ 3+ MCP servers connected
• ✅ Complex multi-step workflows
• ✅ Concerned about token costs or latency
• ✅ Tools that need to interact with each other

Keep Classic MCP if you have:

• ✅ Only 1-2 small MCP servers
• ✅ Simple, direct tool calls
• ✅ Very latency-sensitive use cases (though Code Mode is usually faster)

You can mix both: Enable Code Mode for “heavy” servers (web, documents, databases) and keep small utilities as direct tools.

---

How Code Mode Works

The Four Tools

Instead of seeing 150+ tool definitions, the model sees four generic tools:

The Execution Flow

Key insight: All the complex orchestration happens inside the sandbox. The LLM only receives the final, compact result, not every intermediate step.

---

Why This Matters at Scale

Take a multi-step workflow such as looking up a customer, checking their order history, applying a discount, and sending a confirmation.

Classic MCP: every turn carries the full tool list

With classic MCP, every intermediate result returns to the model, and every next turn includes the complete set of available tool definitions again. As the number of connected MCP servers grows, the model keeps paying to reread the same tool catalog.

Code Mode: discover, write once, execute once

With Code Mode, the model discovers the relevant stubs, writes a short orchestration script, and Bifrost runs the tool calls inside the Starlark sandbox. The intermediate tool results stay inside the sandbox, and the model receives the compact final output.

This is why the savings grow with scale: classic MCP cost grows with every connected tool, while Code Mode cost is bounded by the files and documentation the model actually reads. In the benchmark rounds, this produced 3-4x fewer LLM round trips and input-token savings from 58.2% to 92.8% as tool count increased.

---

Enabling Code Mode

Code Mode must be enabled per MCP client. Once enabled, that client’s tools are accessed through the four meta-tools rather than exposed directly. Best practice: Enable Code Mode for 3+ servers or any “heavy” server (web search, documents, databases).

Go SDK Setup

---

When Code Mode clients are connected, Bifrost automatically adds four meta-tools to every request:

1. listToolFiles

Lists all available virtual .pyi stub files for connected code mode servers. Example output (Server-level binding):

Example output (Tool-level binding):

2. readToolFile

Reads a virtual .pyi file to get compact Python function signatures for tools. Parameters:

• fileName (required): Path like servers/youtube.pyi or servers/youtube/search.pyi
• startLine (optional): 1-based starting line for partial reads
• endLine (optional): 1-based ending line for partial reads

Example output:

3. getToolDocs

Get detailed documentation for a specific tool when the compact signature from readToolFile is not sufficient. Parameters:

• server (required): The server name (e.g., "youtube")
• tool (required): The tool name (e.g., "search")

Example output:

4. executeToolCode

Executes Python code in a sandboxed Starlark interpreter with access to all code mode server tools. Parameters:

• code (required): Python code to execute

Execution Environment:

• Python code runs in a Starlark interpreter (Python subset)
• All code mode servers are exposed as global objects (e.g., youtube, filesystem)
• Tool calls are synchronous - no async/await needed
• Use print() for logging (output captured in logs)
• Assign to result variable to return a value
• Tool execution timeout applies (default 30s)

Syntax notes:

• Use keyword arguments: server.tool(param="value") NOT server.tool({"param": "value"})
• Access dict values with brackets: result["key"] NOT result.key
• List comprehensions work: [x for x in items if x["active"]]

Example code:

---

Binding Levels

Code Mode supports two binding levels that control how tools are organized in the virtual file system:

Server-Level Binding (Default)

All tools from a server are grouped into a single .pyi file.

Best for:

• Servers with few tools
• When you want to see all tools at once
• Simpler discovery workflow

Tool-Level Binding

Each tool gets its own .pyi file.

Best for:

• Servers with many tools
• When tools have large/complex schemas
• More focused documentation per tool

Configuring Binding Level

Binding level is a global setting that controls how Code Mode’s virtual file system is organized. It affects how the AI discovers and loads tool definitions.

---

Auto-Execution with Code Mode

Code Mode tools can be auto-executed in Agent Mode, but with additional validation:

1. The listToolFiles and readToolFile tools are always auto-executable (they’re read-only)
2. The executeToolCode tool is auto-executable only if all tool calls within the code are allowed

How Validation Works

When executeToolCode is called in agent mode:

1. Bifrost parses the Python code
2. Extracts all serverName.toolName() calls
3. Checks each call against tools_to_auto_execute for that server
4. If ALL calls are allowed → auto-execute
5. If ANY call is not allowed → return to user for approval

Example:

---

Code Execution Environment

Available APIs

Runtime Environment Details

Engine: Starlark interpreter (Python subset) Tool Exposure: Tools from code mode clients are exposed as global objects:

Code Processing:

1. Code is validated for syntax errors
2. Tool calls are extracted and validated
3. Code executes in isolated Starlark context
4. Result variable is automatically serialized to JSON

Execution Limits:

• Default timeout: 30 seconds per tool execution
• Memory isolation: Each execution gets its own context
• No access to host file system or network
• Logs captured from print() calls

Error Handling

Bifrost provides detailed error messages with hints:

Timeouts

• Default: 30 seconds per tool call
• Configure via tool_execution_timeout in tool_manager_config
• Long-running operations are interrupted with timeout error

---

Classic MCP injects every available tool definition on every model turn. As you connect more servers, the repeated tool catalog dominates the input context, so cost rises with the size of your MCP footprint. Code Mode keeps that catalog behind four meta-tools. The model discovers the relevant stub files, reads only the signatures and docs it needs, and executes the multi-tool workflow inside the sandbox. In the benchmark rounds above, that kept Code Mode input usage nearly flat while classic MCP grew from 19.9M to 75.1M input tokens. The effect is most visible at large scale: with 508 tools across 16 servers, Code Mode cut input tokens from 75.1M to 5.4M and estimated cost from $377.00 to$29.00, while preserving a 65/65 (100%) pass rate.

---

Next Steps