Scaling MCP Tools with Anthropic's Programmatic Tool Calling

December 27, 2025

Learn how to use Anthropic's code_execution programatic tool calling features with Unified's MCP server to efficiently manage hundreds of tools while maintaining high accuracy and context efficiency.

When building AI applications with MCP servers, including the Unified MCP server, you quickly encounter a critical challenge: most LLM models will hit their model context threshold and stop processing.

And Anthropic's new code_execution feature creates internal Python code that invokes the tool as a function, potentially including multiple tool calls and pre/post-processing logic.

The Problem: Too Many Round Trips For Each Tool Invocation

With the Unified MCP server, you can expose many MCP servers at once for an LLM to perform complex multi-step processes. With 2218 integrations and support for 212,000+ tools, the LLM can be requested to perform very lengthy complicate processes.

But, these multi-step processes cause significant problems:

• Latency: Multi-tool workflows can significantly extend the processing time of a query
• Large token consumption: Running multi-tool workflows will cause a token usage spike as each tool's inout and output must be tokenized for each step
• LLM Model's Context Window: Processing tools, inputs, and outputs for each step in a multi-step process can normally exhaust the LLM model's context window (ie. maximum tokens).

The Solution: Anthropic's Code Execution

Anthropic's code_execution feature works by designating which tools can be called internally by it's code execution feature.

How It Works

1. You include a tool search tool in your tools list
2. You provide all tool definitions with allowed_callers: [ "code_execution_20250825" ]
3. Include a special tool entry:
   {
     "type": "code_execution_20250825",
     "name": "code_execution"
   },
   

4. Claude can now write Python code that invokes the tool as a function, potentially including multiple tool calls and pre/post-processing logic
5. Claude runs this code in a sandboxed container via code execution
6. When a tool function is called, code execution pauses and the API returns a tool_use block

Implementation

To use the new code_execution tool option, follow these instructions (found here) when calling Anthropic's /v1/messages API:

• Add "advanced-tool-use-2025-11-20"  to the anthropic-beta header: anthropic-beta: advanced-tool-use-2025-11-20,mcp-client-2025-11-20
• Add the Unified MCP server's URL for your region with the connection ID, and put a connection-scoped token in authorization_token, which Anthropic sends as the Authorization: Bearer header (the ?token= URL parameter is deprecated)

"mcp_servers": [
  {
    "type": "url",
    "name": "unified-salesforce-server",
    "url": "https://mcp-api.unified.to/mcp?connection=y",
    "authorization_token": "YOUR_CONNECTION_SCOPED_TOKEN"
  }
],

• Then add an additional tools array with configuration on which tools to defer:

"tools": [
  {
    "type": "code_execution_20250825",
    "name": "code_execution"
  },
  {
    "type": "mcp_toolset",
    "mcp_server_name": "unified-salesforce-server",
    "default_config": {
      "defer_loading": true
    },
    "configs": {
      "list_crm_contacts": {
        "defer_loading": false
      }
    }
  }
],

• Use the default_config.defer_loading: true option to make all tools deferrable
• Use the configs.{tool_id}.defer_loading: true/false to set an individual tool to defer (or not)

Or, alternatively, you can call the Unified MCP /tools endpoint with parameters ?type=anthropic&defer_tools=all and then feed that tools result into Anthropic's API.

Best Practices

1. Keep Core Tools Non-Deferred

If you have 3-5 tools that are frequently used, keep them as non-deferred.

2. Use Permissions to Scope Tools

Reduce the tool catalog size by requesting only the permissions you need:

// Instead of all tools across all categories
permissions: 'crm_contact_read,crm_contact_write,crm_deal_read'

// This is better than loading 200+ tools from all categories

3. Restrict Tools

Use the Unified MCP tools parameter to restrict which tools will be returned back to the LLM API.

This has a different effect than the defer_tools parameter as it doesn't return restricted tools to the LLM API at all, while deferring tools means that the LLM API knows about the tool, but doesnt process it until it is needed.

4. Monitor Token Usage

Track your token consumption to understand the benefits:

console.log(`Input tokens: ${response.usage.input_tokens}`);
console.log(`Output tokens: ${response.usage.output_tokens}`);
console.log(`Tool search requests: ${response.usage.server_tool_use?.tool_search_requests}`);

5. Combine with Prompt Caching

Use prompt caching with defer_loading for multi-turn conversations:

messages.push({
    role: "user",
    content: "Now find their recent deals",
    cache_control: { type: "ephemeral" }
});

Tool Search Limits

Be aware of these limits:

• Maximum tools: 10,000 tools in your catalog
• Search results: Returns 3-5 most relevant tools per search
• Pattern length: Maximum 200 characters for regex patterns
• Model support: Claude Sonnet 4.5+ and Opus 4.5+ only

When to Use Defer Loading

Good use cases:

• 20+ tools available from Unified connections
• Multiple integrations (CRM + ATS + HRIS + Storage)
• Building multi-tenant applications where each tenant has different integrations
• Context window is getting tight with tool definitions
• Tool selection accuracy is degrading

When traditional tool calling might be better:

• Less than 10 tools total
• All tools are frequently used in every request
• Very focused single-integration use case

Real-World Example: Multi-Integration Assistant

Here's a practical example of a customer support assistant that accesses multiple integrations:

async function createSupportAssistant(crm_connection_id, hris_connection_id, zendesk_connection_id) {
    // Fetch tools from multiple Unified connections
    const crmTools = await fetchUnifiedTools(crm_connection_id, 'crm_contact_read,crm_deal_read', { type: 'anthropic', defer_tools: 'list_crm_'});
    const ticketingTools = await fetchUnifiedTools(zendesk_connection_id, 'ticketing_ticket_read,ticketing_ticket_write', { type: 'anthropic', defer_tools: 'list_crm_'});
    const hrisTools = await fetchUnifiedTools(hris_connection_id, 'hris_employee_read', { type: 'anthropic', defer_tools: 'list_crm_'});

    // Combine all tools with defer_loading
    const tools = [
        ...crmTools,
        ...ticketingTools,
        ...hrisTools
    ];

    // Total: 150+ tools, with all listX tools being deffered
    return await anthropic.beta.messages.create({
        model: "claude-sonnet-4-5-20250929",
        betas: ["advanced-tool-use-2025-11-20"],
        max_tokens: 4096,
        messages: [{
            role: "user",
            content: "Customer John Doe from Acme Corp called about ticket #12345. Show me his account info, open tickets, and any recent deals."
        }],
        tools: tools
    });
}

Resources

• Unified MCP Server Overview
• MCP Installation & Usage
• MCP Server Options
• Anthropic's Code Execution Documentation
• Anthropic MCP Integration Guide

TLDR

Anthropic's defer_loading feature is a game-changer for building AI applications with Unified's MCP server. By the LLM API dynamically loading tools on-demand, you can:

• Scale to hundreds of tools across multiple integrations
• Reduce context usage by 80-90%
• Improve tool selection accuracy significantly
• Build more capable AI assistants that access diverse data sources

Start by adding the tool search tool and marking your Unified MCP tools as deferred. Monitor your token usage and tool selection accuracy to see the immediate benefits.

The combination of Unified's extensive integration network and Anthropic's intelligent tool search opens up possibilities for building truly comprehensive AI agents that can work across your entire SaaS ecosystem.