Agents & tool use — how AI acts | How AI Works

01 · A model in a loop

Think → act → observe → repeat

An agent is an LLM that can do things: it picks a , your code runs it, the result lands back in the , and the model decides what's next. Step through a real task — including the moment a tool fails.

Goal

Find the cheapest flight from London to Tokyo next month and email me a summary.

Context window

140 tok

02 · The contract

Anatomy of a tool call

The model never executes anything. You hand it a menu of forms (tool schemas); it fills one in; your code does the real work and reports back. The model writes the form — your code is the hands.

1 · What you give the model (schema)

{
  "name": "search_flights",
  "description": "Search for flights between two airports in a date range. Returns up to 10 results sorted as requested.",
  "input_schema": {
    "type": "object",
    "properties": {
      "origin": {
        "type": "string",
        "description": "IATA airport or city code, e.g. 'LHR'"
      },
      "destination": {
        "type": "string",
        "description": "IATA airport code. Must be a specific airport."
      },
      "date_from": {
        "type": "string",
        "format": "date"
      },
      "date_to": {
        "type": "string",
        "format": "date"
      },
      "sort": {
        "type": "string",
        "enum": [
          "price",
          "duration",
          "departure"
        ]
      }
    },
    "required": [
      "origin",
      "destination",
      "date_from",
      "date_to"
    ]
  }
}

2 · What the model emits (tool call)

{
  "type": "tool_use",
  "id": "toolu_01A2B3",
  "name": "search_flights",
  "input": {
    "origin": "LON",
    "destination": "NRT",
    "date_from": "2026-07-01",
    "date_to": "2026-07-31",
    "sort": "price"
  }
}

Structured, validated, machine-parseable. Your runtime executes search_flights(…) and returns the result as the next message.

MCP — the standardization layer

Every app integrating every tool separately doesn't scale. (Model Context Protocol) makes tools portable: write one tool server — for your database, your CRM, your filesystem — and any MCP-capable assistant can use it. USB for AI tools.

03 · Beyond one loop

Patterns, and where agents fall over

Two architectures cover most real systems — and four failure modes cover most real incidents.

Single agent

One model, one loop, all tools. Simple, debuggable, and the right default. Context holds the entire history — fine until tasks get long.

Orchestrator + subagents

A lead agent decomposes the goal and spawns focused subagents, each with a clean context and a narrow toolset. Results come back as summaries, keeping the orchestrator's context small. Costs more tokens; scales to bigger tasks.

Compounding errors

A 95%-reliable step run 20 times succeeds 36% of the time. Loops amplify small error rates — which is why verification steps and retries matter more than raw model quality.

Context exhaustion

Every observation accumulates. Long tasks drown the goal in stale tool output. Mitigations: summarize old steps, evict raw results, externalize memory to files.

Goal drift

After many steps the agent optimizes a sub-goal and forgets the original ask. Mitigation: restate the goal each turn; orchestrators that check work against the original task.

Unsafe actions

An agent with send_email and shell access can do real damage on a bad parse. Mitigations: least-privilege tools, human approval gates for irreversible actions, sandboxing.

Knowledge check

Did it stick?

1/3When an agent 'sends an email', what does the model itself actually do?

2/3A tool call fails with an error. What makes a well-built agent recover?

3/3Each step of your agent succeeds 95% of the time. Across 20 sequential steps, roughly how often does the whole task succeed without intervention?

Loading module…

Common questions this module answers

What is an AI agent?

An LLM in a loop: it reasons about a goal, chooses a tool (search, code, email), your code executes the tool, the result is appended to context, and the model decides the next step — repeating until the goal is done.

How does LLM tool calling actually work?

You describe tools as JSON schemas. The model emits a structured tool call (name + arguments) instead of prose; your code runs the real function and returns the result as a new message. The model never executes anything itself.

What is MCP (Model Context Protocol)?

An open standard that lets any AI app talk to any tool server over one protocol — write a tool server once, use it from any MCP-capable assistant, instead of integrating each tool with each app.