Multi-Tool Orchestration

A single model turn doesn't have to request just one tool. Given a question like "what's the weather in Lisbon and Tokyo?", a model can — and by default, on both major providers, will — return more than one tool call in the same response: two tool_use blocks from Anthropic, or two entries in tool_calls from OpenAI. This is a real efficiency win: instead of two full round trips to the model, one per city, you get both requests up front and can execute them concurrently.

The rule that trips people up is what happens next: every call in that batch needs a matching result before you send anything back. Anthropic's documentation is explicit that all tool_result blocks belong in a single next user message, not spread across separate turns — the model is waiting on the whole batch, not the first one to finish.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[weather_tool],
    messages=[{"role": "user", "content": "What's the weather in Lisbon and Tokyo?"}],
)
tool_uses = [b for b in response.content if b.type == "tool_use"]
print(f"Model requested {len(tool_uses)} tool calls")

Both providers let you turn parallel calling off when you specifically want at most one tool used per turn — useful when a workflow genuinely can't handle two actions landing at once, or when you're debugging and want to see calls one at a time. On Anthropic, this lives inside tool_choice: setting disable_parallel_tool_use: true alongside tool_choice: {"type": "auto"} caps the model at zero or one tool calls, while the same flag alongside type: "any" or type: "tool" forces exactly one. OpenAI's equivalent is a top-level parallel_tool_calls: false on the request.

tool_choice itself controls a related but separate question — not how many tools, but which: OpenAI's values are "auto" (default), "required" (call at least one), a forced specific function, or "none"; Anthropic's are "auto", "any" (call some tool), a forced named tool, or "none" — different vocabulary, the same four underlying behaviors.

response = client.chat.completions.create(
    model="gpt-5.6",
    messages=[{"role": "user", "content": "What's the weather in Lisbon and Tokyo?"}],
    tools=[weather_tool],
    parallel_tool_calls=False,
)

Once a project accumulates dozens of tools, exposing every schema on every request gets expensive and can hurt accuracy — the model has to weigh more options each turn, and every schema counts against your context and your bill. OpenAI's answer is to group related tools into namespaces and let tool_search defer loading a tool's full definition until the model actually decides it's relevant, rather than paying that token cost up front on every call. Its own guidance suggests keeping the initially available set small — under roughly twenty tools at the start of a turn — and reaching for deferred loading once you're past that.

Anthropic doesn't ship an identically named feature, but the underlying advice is the same: keep the active tool set focused, because too many tools can confuse a model into calling the wrong one or missing an obviously relevant one entirely.