"Function calling" and "tool use" describe the same broad capability: the model decides to invoke an external operation, you execute it, and the result feeds back into the conversation. The terminology choice is mostly historical and mostly cosmetic. The interesting differences are in how each provider exposes it.

What each provider calls it

OpenAI uses two related but distinct terms in its docs:

  • Function calling — the model emits a tool call (function name + JSON arguments) for you to execute. Covered in the function calling guide.
  • Structured outputs — the model emits schema-conformant JSON without invoking a tool. Covered separately. Easy to conflate; not the same thing.

Anthropic uses tool use as the umbrella term in the tool use docs. Functions are one category of tool. Other tools (computer use, code execution, web search) live under the same API surface.

Google Gemini documents function calling as part of a broader "tools" framework in the Gemini function calling docs. Same idea, slightly different request and response shape.

The taxonomy that matches reality across the three:

  • All function calling is tool use.
  • Not all tool use is function calling — retrieval tools, code execution, computer use, and search are all tools that are not "functions" in the classic sense.

The request shape

All three providers accept a list of tool definitions. The wrapper differs; the inner schema is JSON Schema everywhere.

OpenAI (Responses API):

{
  "model": "gpt-5.x",
  "input": "...",
  "tools": [
    {
      "type": "function",
      "name": "get_weather",
      "description": "Get current weather for a city",
      "parameters": {
        "type": "object",
        "properties": { "city": { "type": "string" } },
        "required": ["city"]
      }
    }
  ]
}

Anthropic (Messages API):

{
  "model": "claude-...",
  "messages": [...],
  "tools": [
    {
      "name": "get_weather",
      "description": "Get current weather for a city",
      "input_schema": {
        "type": "object",
        "properties": { "city": { "type": "string" } },
        "required": ["city"]
      }
    }
  ]
}

Gemini:

{
  "contents": [...],
  "tools": [{
    "functionDeclarations": [
      {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
      }
    ]
  }]
}

Three providers, same idea, different envelopes.

The response shape

The pattern is similar across all three:

  1. The model emits a tool-call object (with the tool name and arguments) instead of a final text response.
  2. You execute the tool.
  3. You send the tool result back as a new message (the exact shape differs per provider, but they all expect a structured result tied to the call ID).
  4. The model takes the result and continues — usually producing the final answer, sometimes calling another tool first.

Differences worth knowing

  • Parallel tool calls. OpenAI and Anthropic both support a single model response containing multiple tool calls to be run in parallel. Useful when the steps are independent.
  • Strict mode / JSON-schema validation. OpenAI's strict mode enforces the schema at decode time. Anthropic does the same for its strict tool-input validation. Use these. They cut "the model emitted invalid JSON" failures dramatically.
  • Streaming tool-call deltas. All three providers support streaming the tool-call as it is generated, which matters for very long arguments or latency-sensitive UIs.

What to standardize on

If you are building one product on one provider, use their term. If you are building infrastructure that targets all three, "tool" is the more useful umbrella — it survives the addition of non-function tools (computer use, code execution, search, retrieval, MCP-mediated operations) without renaming.

A thin internal abstraction over the three APIs is usually one file. The wrapper differences are cosmetic; the substance is the same.