Tool Use Patterns

What it is

Tool use patterns define how AI agents select, invoke, and combine external tools to solve tasks. While function calling is the technical mechanism and MCP is the discovery protocol, tool use patterns are the higher-level strategies that determine when, how, and in what order to invoke tools.

Tool definitions

Definition quality determines whether the model selects the right tool. A definition includes a name, description, and typed input schema.

Function calling example (OpenAI/Bedrock)

{
  "type": "function",
  "function": {
    "name": "search_knowledge",
    "description": "Search the knowledge base by query. Returns matching concepts with titles, summaries, and relevance scores. Use when the user asks about a topic.",
    "parameters": {
      "type": "object",
      "properties": {
        "query": {
          "type": "string",
          "description": "Search query — use specific terms, not full sentences"
        },
        "limit": {
          "type": "integer",
          "description": "Max results to return (default: 5)",
          "default": 5
        }
      },
      "required": ["query"]
    }
  }
}

MCP example

server.tool("search_knowledge", {
  description: "Search the knowledge base by query. Returns matching concepts with titles, summaries, and relevance scores.",
  inputSchema: {
    type: "object",
    properties: {
      query: { type: "string", description: "Search query" },
      limit: { type: "integer", description: "Max results", default: 5 }
    },
    required: ["query"]
  }
}, async ({ query, limit }) => {
  const results = await searchIndex(query, limit);
  return { content: [{ type: "text", text: JSON.stringify(results) }] };
});

The key difference: in function calling, the host executes the function and returns the result to the model. In MCP, the server executes the tool and the protocol handles transport. The definition schema is nearly identical — what changes is who executes and how discovery works.

Invocation patterns

Single tool

The simplest case — the agent identifies one tool and invokes it once:

Parallel calls

When tools are independent, the agent invokes them simultaneously. Significantly reduces latency:

Chained calls

One tool's result feeds the next tool's input. The most common pattern in agentic workflows:

Conditional selection

The agent decides which tool to use based on the question's context:

Tool description quality is what enables the model to make this selection correctly. Ambiguous descriptions produce incorrect selections.

Tool selection strategies

When an agent has access to many tools (10+), selection becomes a prompt engineering problem:

Category filtering is the most practical for most systems. Example: a technical support agent loads "database" tools only when it detects a data question, and "deployment" tools only for infrastructure questions.

Error handling

Tool errors are inevitable. The agent needs strategies to handle them without failing silently:

Retry with backoff

Fallback to alternative tool

Graceful degradation

Error anti-patterns

• Retrying infinitely — always define a maximum retry count
• Ignoring errors — the agent must communicate to the user when a tool fails
• Passing raw errors — transform technical errors into comprehensible messages
• Not validating responses — verify the tool response has the expected structure before using it

Tool composition

The most advanced patterns combine multiple tools in complex flows:

Pipeline

Linear sequence where each step transforms the previous result:

Fan-out / Fan-in

Distribute work in parallel and aggregate results:

Loop with exit condition

The agent iterates until meeting a criterion:

This pattern is the foundation of the "agent loop" in frameworks like Strands Agents — the model reasons, invokes tools, evaluates results, and decides if it needs more information.

Function calling vs MCP — when to use each

In practice, function calling is sufficient for an application's internal tools. MCP is necessary when tools must be accessible from multiple AI clients or when dynamic discovery matters.

Why it matters

Tool use patterns are what turns an LLM into an agent capable of acting in the real world. Without tools, a model can only generate text. With well-designed tools and correct invocation patterns, it can query databases, execute code, interact with APIs, and orchestrate complex flows.

The difference between a reliable agent and a fragile one is in the details: precise descriptions that guide selection, typed schemas that prevent input errors, error handling that degrades gracefully, and composition that enables solving tasks no single tool can complete. These patterns are transferable across providers — whether it's Bedrock function calling, the Anthropic API, or an MCP server.

References

• Tool Use — Anthropic — Anthropic. Official tool use documentation with Claude, including patterns and schemas.
• Tool Use Best Practices — Anthropic — Anthropic. Best practices for tool definition and usage.
• Building Effective Agents — Anthropic, 2024. Agent patterns including tool orchestration.
• Model Context Protocol — Anthropic/Linux Foundation. Standard protocol for tool discovery and use.
• Tool Use with Converse API — Amazon Bedrock — AWS. Tool use implementation in Bedrock.
• Tools and Tool Calling — Vercel AI SDK — Vercel. Multi-provider tool calling abstraction.