Claude Tool Use: Code Execution, Text Editor & Web Search

What is Tool Use?

Tool Use (or function calling) is Claude's ability to use external tools during a conversation. Instead of simply responding with text, Claude can:

1. →Decide that a tool is needed to answer
2. →Generate the tool call parameters in JSON format
3. →Receive the result of the tool execution
4. →Use that result to formulate a complete response

The Tool Use Flow

User → Claude (thinks) → Tool call (JSON)
                              ↓
                         Your code executes the tool
                              ↓
Result → Claude (uses the result) → Final response

The honest read on tool use / function calling in 2026, from practitioners on r/LangChain, r/LocalLLaMA, and r/MachineLearning: tool use is where LLMs stop being chatbots and start being agents, and it's also where most production systems discover that agent loops are much harder to make reliable than single calls. The mechanics — Claude emits a JSON tool call, your code runs it, you pass the result back — are well-documented in the Anthropic tool use guide. What is under-documented is that every tool you expose is a new failure mode: wrong tool chosen, right tool with wrong arguments, tool execution error the model can't recover from, or (the classic) an infinite retry loop when the model doesn't understand why its last call failed.

Where the community correctly pushes back on "just give the agent every tool": tool-selection accuracy degrades quickly as the tool count rises. The Berkeley Function-Calling Leaderboard and the ToolBench research both show that models that are near-perfect on 3-5 tools fall off sharply past 15. The right answer is hierarchical tools (a dispatcher tool that routes to sub-tools), tight descriptions, and input schemas that are strict enough to refuse nonsense.

Pragmatic rule from engineers who've shipped agents without wake-up calls: start with three tools, log every tool call with its arguments and result, and only add a new tool when you have data showing the current set is insufficient. Every tool you add makes the ones you already have work slightly worse.

Built-in Tools

Claude has three built-in tools that require no implementation on your part.

1. Code Execution (Python Sandbox)

The Code Execution tool allows Claude to run Python code in a secure sandbox environment. Ideal for calculations, data analysis, and chart generation.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    tools=[{
        "type": "code_execution"
    }],
    messages=[{
        "role": "user",
        "content": "Calculate the mean, median, and standard deviation of this data: [23, 45, 67, 12, 89, 34, 56, 78, 91, 43]"
    }]
)

Use cases: Mathematical calculations, statistical analysis, matplotlib chart generation, pandas data manipulation.

Limitations: Isolated sandbox, no network access, no persistence between calls, limited libraries (numpy, pandas, matplotlib available).

2. Text Editor

The Text Editor tool allows Claude to read, create, and modify files. Primarily used in Claude Code and development agents.

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    tools=[{
        "type": "text_editor_20250429",
        "name": "text_editor"
    }],
    messages=[{
        "role": "user",
        "content": "Read the config.json file and change the port from 3000 to 8080."
    }]
)

Available commands:

3. Web Search

The Web Search tool allows Claude to search for up-to-date information on the web.

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    tools=[{
        "type": "web_search"
    }],
    messages=[{
        "role": "user",
        "content": "What are the latest AI news in March 2026?"
    }]
)

Use cases: Up-to-date information, fact checking, documentation search, product pricing and availability.

Custom Tools (Function Calling)

Custom tools let you connect Claude to any API or function in your application.

Defining a Custom Tool

import anthropic
import json

client = anthropic.Anthropic()

# Tool definition
tools = [{
    "name": "get_weather",
    "description": "Gets the current weather for a given city. Use this tool when the user asks about the weather.",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "The city name (e.g., 'Paris', 'London')"
            },
            "units": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["city"]
    }
}]

# First request
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "What's the weather like in Paris?"
    }]
)

The Complete Tool Use Cycle

Tool Use works in a loop. Here is the complete pattern:

def run_tool_loop(user_message, tools, tool_handlers):
    """Execute a complete tool use loop."""
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )
        
        # If Claude is done (no tool call)
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        # Process tool calls
        messages.append({"role": "assistant", "content": response.content})
        
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                # Execute the tool
                handler = tool_handlers[block.name]
                result = handler(**block.input)
                
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result)
                })
        
        messages.append({"role": "user", "content": tool_results})

# Tool handlers
def get_weather(city, units="celsius"):
    # Call a real weather API
    return {"city": city, "temp": 18, "condition": "Sunny"}

# Execution
result = run_tool_loop(
    "What's the weather in Paris and London?",
    tools=tools,
    tool_handlers={"get_weather": get_weather}
)

Parallel Tools

Claude can call multiple tools simultaneously when it needs several independent pieces of information:

# Claude can generate multiple tool_use blocks in a single response:
# [
#   {"type": "tool_use", "name": "get_weather", "input": {"city": "Paris"}},
#   {"type": "tool_use", "name": "get_weather", "input": {"city": "London"}}
# ]

Advanced Patterns

Forcing Tool Use

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "get_weather"},  # Force this tool
    messages=[{"role": "user", "content": "Paris"}]
)

Structured Extraction via Tool Use

A powerful pattern: using Tool Use to force Claude to return structured data.

tools = [{
    "name": "extract_contact",
    "description": "Extracts contact information from text.",
    "input_schema": {
        "type": "object",
        "properties": {
            "name": {"type": "string"},
            "email": {"type": "string"},
            "phone": {"type": "string"},
            "company": {"type": "string"}
        },
        "required": ["name"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "extract_contact"},
    messages=[{
        "role": "user",
        "content": "Marie Dupont is a director at TechCorp. Contact her at marie@techcorp.com or at +33 6 12 34 56 78."
    }]
)

# Guaranteed structured result:
# {"name": "Marie Dupont", "email": "marie@techcorp.com", "phone": "+33 6 12 34 56 78", "company": "TechCorp"}

What Works Best

Writing Good Tool Descriptions

The tool description is critical, it's what Claude uses to decide when and how to use it.

Best Practices Checklist

1. →Detailed descriptions, Explain when and why to use the tool
2. →Documented parameters, Each parameter should have a clear description
3. →Server-side validation, Never trust parameters without validation
4. →Error handling, Return clear error messages in tool_results
5. →Limit the number of tools, 10-20 tools maximum for optimal performance
6. →Explicit names, search_products rather than search or sp

Common Errors

• →Advanced MCP: Transports and Patterns, Explore advanced Model Context Protocol patterns