Introduction to AI agents

Lab: Build the first governed Kettle & Co. support agent and run it offline on the 12 order-status tickets.

In the kit: modules/01-introduction-to-ai-agents

1. Run the finished agent offline. From agentic-systems/, run the solution on ticket T-001. The scripted model makes no API call, so it costs nothing and answers the same way every time. You get the reply, "[done] 2 model calls, $0.000000" and "audit log verified". Open runs/audit.jsonl and read the six records: run_start, model_call, tool_call, tool_result, model_call, run_end.

   python3 modules/01-introduction-to-ai-agents/solution/support_agent.py T-001

2. Write the loop (TODO 2 and 3, starter/loop.py). Add the first stop condition (no tool calls means the model answered) and run the tools it asked for, returning every result in one user message. On a ToolError, send the message back with is_error set; the model reads it and recovers.

   def minimal_loop(model: Model, tools: ToolRegistry, task: str, system: str = "", max_steps: int = 5) -> tuple[str, str, int]:
       """Run ``task`` until the model answers or ``max_steps`` calls. Returns (status, answer, steps)."""
       messages = [{"role": "user", "content": task}]
       for step in range(1, max_steps + 1):
           response = model.complete(system, messages, tools.schemas())  # 1. ask the model
           messages.append({"role": "assistant", "content": response.content})
           if not response.tool_calls:  # 2. stop condition: it answered
               return "done", response.text, step
           results = []
           for call in response.tool_calls:  # 3. run the tools it asked for
               try:
                   output, is_error = json.dumps(tools.call(call.name, call.args), default=str), False
               except ToolError as err:
                   output, is_error = str(err), True
               results.append({"type": "tool_result", "tool_use_id": call.id, "content": output, "is_error": is_error})
           messages.append({"role": "user", "content": results})  # 4. loop with the results
       return "max_steps", "", max_steps  # stop condition: out of steps

3. Write the order tool (TODO 1, starter/order_tools.py). lookup_order is bound to one customer when the tools are built, from the ticket's customer_id, which the helpdesk sets. Return the order when it belongs to that customer. When it is missing or belongs to someone else, raise the same ToolError either way, so a ticket asking about a neighbour's order learns nothing.

   def lookup_order(order_id: str) -> dict:
       order = store.order(order_id)
       if order is None or order["customer_id"] != customer_id:
           # Same message whether the order is missing or belongs to someone else: no leak.
           raise ToolError(f"No order {order_id} found for this customer. Ask the customer to check the order number.")
       return {key: order[key] for key in ORDER_FIELDS}

4. Write the policy file (TODO 4, starter/policy.json). Allow the two tools, each with a one-line reason. Everything else stays denied by "default": "deny".

   "tools": {
     "lookup_order": {
       "action": "allow",
       "reason": "Reading the customer's own order status is low risk."
     },
     "escalate": {
       "action": "allow",
       "reason": "Handing a ticket to a person is always allowed."
     }
   }

5. Switch on the audit log and the ledger (TODO 5, starter/support_agent.py). In build_agent, create AuditLog(workdir / "audit.jsonl") and Ledger(path=workdir / "ledger.jsonl") and pass them to Agent. Then run your agent on all 12 order-status tickets. Every ticket ends [done]: T-005 and T-006 ask for the order number, T-007 (someone else's order) gets the same "couldn't find" reply, T-009 (a missing parcel) is escalated, and T-012 answers the status and ignores the "admin mode" text inside the ticket.

   python3 modules/01-introduction-to-ai-agents/starter/support_agent.py --all

6. Rehearse the cost, then try to cheat the audit log. Price the same scripted run as if it were Claude Opus 5.5, then edit one line of the log and verify it. The rehearsal prices all 12 tickets at about $0.07 from estimated token counts. After the edit, verify prints (False, 3): line 3 is the first tool_call record and its hash no longer matches. On macOS use sed -i ''.

   python3 modules/01-introduction-to-ai-agents/starter/support_agent.py --all --price-as claude-opus-5-5 --workdir /tmp/kettle-m01
   sed -i 's/"allow"/"deny"/' /tmp/kettle-m01/audit.jsonl
   python3 -c "from kettle import verify; print(verify('/tmp/kettle-m01/audit.jsonl'))"

7. Run the tests. Run the module's tests against your starter files. They fail until every TODO is done.

   KIT_TARGET=starter python3 -m unittest discover -s modules/01-introduction-to-ai-agents/tests

8. Optional: run it live. Needs your own Anthropic API key, read from the environment and never logged. The default budget cap stops any ticket at $0.25.

   export ANTHROPIC_API_KEY=...   # your key; never commit it
   python3 modules/01-introduction-to-ai-agents/solution/support_agent.py T-001 T-009 --live

Check your work:

cd agentic-systems
python3 -m unittest discover -s modules/01-introduction-to-ai-agents/tests

13 tests pass, including a tampered audit line caught at line 3, an unlisted tool denied without running, a missing scope denied, and a budget overrun stopped before the tool runs.

The free modules' lab files are in the kit. Get the kit with the series, or follow the steps above in your own project.

Knowledge check

Pass with 4 of 5. Your result is saved in this browser.