What an Agent Actually Is

Strip away the hype and an agent is one small idea: a model that runs in a loop, calls tools, sees the results, and decides when it's done. Everything hard about the job comes from that loop — the cost of each turn, the ways it fails, and knowing when you shouldn't have used one at all.

Here is the shape of every agent, from a two-line script to a coding assistant that edits your repo:

The agent loop, in words

while not done:
    decision = model(context)         # the LLM picks the next action
    if decision.is_final_answer:
        done = True                   # stop: return the answer
    else:
        result = run_tool(decision)   # act on the world
        context += result             # observe: feed the result back

That's it. The model doesn't "have agency" in any mystical sense — it emits either a final answer or a request to call a tool, your code runs the tool, and you paste the result back into the conversation and ask again. The intelligence is the model's; the agency — the loop, the tools, the stopping rule, the guardrails — is yours to engineer. An AI Agent Engineer owns that scaffolding, and almost every production failure lives in it, not in the model.

Agent vs. workflow — the distinction that decides your architecture

The word "agent" gets stretched to cover things that aren't agents, and the difference is not academic — it changes what you build and how it fails.

A workflow is a fixed path you wrote: retrieve, then summarize, then classify. The LLM fills in steps, but the control flow is hard-coded. It's predictable, cheap, and easy to test.

An agent lets the model decide the control flow at runtime: which tool, in what order, how many times, when to stop. That flexibility is the whole point — and the whole danger. You trade predictability for the ability to handle tasks whose steps you couldn't enumerate in advance.

Why the loop is expensive — the numbers that shape every design choice

Each turn of the loop is a full model call that re-reads the entire growing conversation. That has two consequences engineers consistently underestimate.

Cost grows super-linearly with steps. Turn 1 sends 1,000 tokens. But turn 2 resends turn 1's context plus the tool result, turn 3 resends all of that, and so on. A task that takes 8 tool-calling steps doesn't cost 8× a single call — because the context accumulates, it's closer to quadratic. Concretely: a single 1,000-token call is trivial; the same task dragged out to 8 steps, each re-sending a context that has grown to ~6,000 tokens by the end, can burn 30,000–40,000 input tokens total. Fewer steps isn't just faster — it's the single biggest lever on your bill.

Latency stacks. Each step is a sequential round-trip — the model can't take step 2 until it sees step 1's result. At ~2 seconds per call, an 8-step task is a 16-second wait. Users feel every step. "Make the agent take fewer steps" is therefore the recurring theme of this entire book: through planning (Ch. 4), memory (Ch. 5), and reflection used sparingly (Ch. 11).

The three things that make a loop an agent

1. Tools — the actions it can take (Ch. 2). No tools, no agency; it's just a chatbot.
2. A stopping rule — how the loop ends (Ch. 3). Get this wrong and it runs forever or quits early.
3. State — what it remembers across turns (Ch. 5). The context is the memory until you outgrow it.

You'll build the smallest possible version of all three in the lab, then spend the rest of the book making each one production-grade.

Starter code

import anthropic, re

USE_REAL_API = False        # flip to True with a key; mock runs free

TOOLS = [{
    "name": "calculator",
    "description": "Evaluate a basic arithmetic expression, e.g. '3 * (4 + 5)'.",
    "input_schema": {"type": "object",
        "properties": {"expr": {"type": "string"}}, "required": ["expr"]},
}]

TASK = ("A cart has 3 boxes of 12 apples and 5 boxes of 9 apples. "
        "Remove 7 apples, then split the rest evenly among 4 people. "
        "How many does each person get? Use the calculator for every step.")

def run_tool(name, args):
    if name == "calculator":
        return str(eval(re.sub(r"[^0-9+\-*/(). ]", "", args["expr"])))
    return "unknown tool"

def agent(task, max_steps=8):
    messages = [{"role": "user", "content": task}]
    total_in = 0
    for step in range(max_steps):
        resp = call_model(messages)                 # returns a message object
        total_in += approx_tokens(messages)         # what we PAID to send this turn
        messages.append({"role": "assistant", "content": resp["content"]})
        tool_uses = [b for b in resp["content"] if b["type"] == "tool_use"]
        if not tool_uses:                           # no tool call => final answer
            print(f"{step+1} steps, ~{total_in} total input tokens")
            return resp
        results = []
        for tu in tool_uses:
            out = run_tool(tu["name"], tu["input"])
            results.append({"type": "tool_result", "tool_use_id": tu["id"], "content": out})
        messages.append({"role": "user", "content": results})

def approx_tokens(messages):
    return sum(len(str(m["content"])) for m in messages) // 4   # ~4 chars/token

# TODO: implement call_model(): if USE_REAL_API, use
# client.messages.create(model="claude-opus-4-8", max_tokens=500, tools=TOOLS,
#   messages=messages) and adapt .content; else return the next _MOCK turn.

_MOCK = [   # one entry per model turn
  {"content": [{"type":"tool_use","id":"t1","name":"calculator","input":{"expr":"3*12"}}]},
  {"content": [{"type":"tool_use","id":"t2","name":"calculator","input":{"expr":"5*9"}}]},
  {"content": [{"type":"tool_use","id":"t3","name":"calculator","input":{"expr":"(36+45-7)/4"}}]},
  {"content": [{"type":"text","text":"Each person gets 18 apples (74/4 rounds... actually 18.5)."}]},
]
_turn = {"i": 0}
def call_model(messages):
    if USE_REAL_API:
        import anthropic
        c = anthropic.Anthropic()
        r = c.messages.create(model="claude-opus-4-8", max_tokens=500,
                              tools=TOOLS, messages=messages)
        return {"content": [b.model_dump() for b in r.content]}
    m = _MOCK[_turn["i"]]; _turn["i"] += 1
    return m

agent(TASK)   # => "4 steps, ~T total input tokens"