What an Agent Is

Take away the hype and an agent is one small idea: a model running in a loop, calling tools, reading the results and deciding when it's finished. The hard parts of the job come from that loop: what each turn costs, how it fails, and when you shouldn't have used one.

The loop

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 all it is. The model either gives a final answer or asks to call a tool. Your code runs the tool, adds the result to the conversation and asks again. The model provides the reasoning; the loop, the tools, the stopping rule and the safeguards are yours to build, and that's where most production failures happen.

Agent or workflow?

A workflow is a fixed path you wrote: retrieve, then summarize, then classify. The model fills in steps, but your code decides the order. It's predictable, cheap and easy to test.

An agent lets the model choose the path at runtime: which tool, in what order, how many times, when to stop. That flexibility is the point, and it's also the risk. You give up predictability in exchange for handling tasks whose steps you couldn't list in advance.

Why each step costs more than the last

Every turn is a full model call that rereads the whole conversation so far. Turn 1 sends 1,000 tokens. Turn 2 resends turn 1 plus the tool result, turn 3 resends all of that, and so on. An eight-step task doesn't cost eight times a single call; because the context keeps growing, it's closer to quadratic. By step 8 the context might be 6,000 tokens, and the task as a whole can use 30,000 to 40,000 input tokens. Cutting steps is the biggest lever you have on cost.

Latency adds up the same way. Each step waits for the previous one, so at about two seconds per call, an eight-step task takes 16 seconds. Much of this book is about reaching the goal in fewer steps.

What turns a loop into an agent

Three things. Tools, the actions it can take (Chapter 2); without them it's a chatbot. A stopping rule (Chapter 3); get it wrong and it runs forever or quits early. And state, what it remembers across turns (Chapter 5).

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"