Tool Use, Function Calling & ReAct Agents

A common misconception is that the model itself runs Python code, visits websites, or executes database queries. It does not. The LLM only ever outputs tokens.

When tool calling is enabled, the model is trained to pause text generation when it spots an information gap and instead emit a structured tool_calls JSON payload naming a function and its arguments. Your application runs the real code, then feeds the result back to the model.

[
  { "role": "user", "content": "What is the weather in Tokyo right now, and should I bring an umbrella?" }
]

How does the model know what functions are available and what parameters they require? When you make an API request (e.g. OpenAI or Anthropic), you pass an array of tools defined as JSON Schema.

Parameter descriptions act as instructions to the model. A vague description like "query": "string" often leads to malformed inputs, whereas "query": "ISO 8601 formatted date e.g. 2026-11-15" guarantees clean extraction.

{
  "name": "create_calendar_event",
  "description": "Create an appointment on Google Calendar with title, ISO start time, and attendees list.",
  "parameters": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string",
        "description": "Title of the calendar invite"
      },
      "start_iso": {
        "type": "string",
        "description": "Start time formatted as ISO 8601 (e.g. 2026-11-15T14:00:00Z)"
      },
      "duration_minutes": {
        "type": "integer",
        "description": "Duration in minutes, default 30"
      },
      "attendees": {
        "type": "array",
        "description": "List of email addresses to invite"
      }
    },
    "required": [
      "title",
      "start_iso"
    ]
  }
}

{
  "title": "Architecture Review",
  "start_iso": "2026-11-15T15:00:00Z",
  "duration_minutes": 45,
  "attendees": [
    "dev@company.com"
  ]
}

A single tool call lets an LLM answer simple queries like "what is the stock price of Apple?". Real-world problem solving, however, requires multi-step investigation: checking an inventory, looking up an address, calculating shipping fees, and finally confirming an order.

The ReAct pattern (Reason + Act) alternates between thinking out loud (Thought), invoking an action (Action), and reading the environment's response (Observation) in a loop until the goal is achieved.

In early agent architectures, if a user asked "Compare temperatures in London, Tokyo, and New York", the model had to make three separate LLM round-trips sequentially.

With Parallel Tool Calling, the model emits an array of multiple tool invocations in a single response. Your backend dispatches them concurrently via asynchronous workers, cutting latency by up to 70%.

Autonomous agents introduce new engineering failure modes that simple chatbots never face:

initiate_wire_transfer(amount=4500, recipient="acct_9918", currency="USD")

Agents are powerful, but they are nondeterministic, slower, and significantly more expensive than traditional software. Choosing the right tool for the job is the mark of a senior AI engineer.

• LLMs don't run code: They emit structured JSON function arguments that your backend application executes.
• JSON Schema is the contract: Clear parameter types and descriptions guide the model's tool selection and argument formatting.
• ReAct loops enable multi-step autonomy: Alternating Thought, Action, and Observation lets agents solve complex, branching tasks.
• Parallel tool calls optimize latency: Modern models emit multiple tools in one turn to be executed concurrently.
• Guardrails protect production: Always enforce maximum iteration limits, idempotency keys, and Human-in-the-Loop approvals for destructive actions.