Chapter 13 — Reps

Eleven reps to turn “I read about agents” into “I have supervised one and caught it.” They move from telling an agent apart from a chatbot, to decomposing a goal, to running real agents and gating them, to writing the governance that keeps a delegation honest. The keyboard is the gym. Do not read these — run them.

Ground rules

• Do it yourself first. Before you delegate a task, spend two minutes doing the first step by hand. You cannot supervise work you have never done.
• Run everything. Actually open the agent, actually watch it act. A rep you only imagined is a rep you did not do. (Free tiers of ChatGPT, Gemini, Claude, and Perplexity are enough — see Appendix A.)
• Predict before you measure. Before you run an agent, write down the plan you expect it to make and where you think it will go wrong. Then compare. The gap is the learning.
• AI policy (Phase 2 — agentic): You will use agents here. Every rep that uses one ends with an honest one-line AI usage note: what you delegated, where it was wrong, what you verified. Supervision that leaves no record is not supervision.
• Keep a reps.txt. One short written reflection per rep (a doc, not code). This is graded thinking, not busywork.

Reps 1–3: Tell an agent from a chatbot, and plan a delegation

Rep 1 — The one-question test

Pick three AI tools or features you can reach today (e.g., a plain chat window, a “Deep Research” button, an email assistant, a scheduling helper). For each, answer the single question that separates the categories: can it take an action in the world on its own, or does it only produce words on my screen? Label each chatbot or agent and name the specific action (or lack of one) that decided it.

Reflection: Which of the three surprised you? Most people discover at least one “chatbot” that quietly has hands. Which mistake could it make off your screen?

Rep 2 — Decompose before you delegate

Take a real multi-step task from your own work (plan an event, research three vendors, prep a report). Open code/task-breakdown.txt and fill in sections A–E: the goal, the success criteria, the steps, and — the important part — mark each step green (safe to delegate), yellow (needs your approval), or red (never delegate).

Reflection: How many steps came out red? Name the one you were tempted to mark green but shouldn’t. What made it red — irreversible, external, confidential, or your judgment call?

Rep 3 — Predict the plan

Before running any agent, write the plan you think an agent should make for your Rep 2 goal — the ordered steps and the tool each would need. Keep it; you will check the agent’s real plan against it in Rep 5.

Reflection: Where do you predict the agent’s plan will differ from yours? Predicting the disagreement is how you spot it fast when it happens.

Reps 4–6: Run real agents and watch them work

Rep 4 — Run a research agent, then check its homework

Use a “Deep Research” mode (Perplexity’s free tier works; ChatGPT, Gemini, and Claude often gate Deep Research behind paid plans — see Appendix B, and use whichever you can reach) on a question you genuinely care about and can partly verify. Let it produce its cited report. Then open every citation on the three most important claims and mark each supported (the source really says it) or unsupported (it doesn’t, or the link is broken/invented).

Reflection: What was your supported-vs-unsupported count? Was any unsupported claim also one of the most confident-sounding? Tie this back to Chapter 8. End with your AI usage note.

Rep 5 — Watch the loop step by step

Run an agent (an agent mode you have access to, or the Agent Step-Tracer widget below the chapter) on a small task and record its moves in a plain table: for each step, what it did, which tool it used, and what it observed. Compare the real plan to the one you predicted in Rep 3.

Step | What it did              | Tool used      | What it observed
-----+--------------------------+----------------+------------------
  1  |                          |                |
  2  |                          |                |
  3  |                          |                |

Reflection: Where did the agent’s real plan diverge from your prediction? Did any step build on an earlier result that was already a little wrong? That is the loop compounding — describe it.

Rep 6 — Find the memory

In whatever assistant you use most, locate the memory / saved-context setting. Read what it has stored about you. Add one harmless preference (e.g., “I prefer short bullet points”), confirm it sticks in a later chat, then find how to view and clear it.

Reflection: Was anything already saved that you did not expect? State the rule in your own words: what belongs in long-term memory, and what must never go there?

Reps 7–9: Gate it, govern it, and know which agent you’re in

Rep 7 — Toggle the gate

In the Agent Step-Tracer below the chapter, run the same task twice: once with the human-approval gate ON (approve/deny each consequential action) and once with it OFF (fully autonomous). Note where the agent paused with the gate on, and what sailed through with it off.

Reflection: For your own Rep 2 task, at which specific steps would you require a gate, and which would you actually let run gate-off? Defend one gate-off choice by naming why it is reversible, bounded, and low-stakes.

Rep 8 — Write your never-delegate list

For your real role, write the list of actions you will never let an agent take on its own — the red lines from code/task-breakdown.txt section E, made specific to your job. Money movement, anything sent externally in your name, anything touching confidential data, and any decision your name is on default to this list.

Reflection: Pick the one red line you think a busy version of you would be most tempted to cross for convenience. What guardrail (a gate, a second approver, a habit) would stop future-you?

Rep 9 — Personal vs enterprise, on your own data

Write down one task you would happily give a personal agent and one you would only give an enterprise agent (governed, logged, with a data agreement). Then find out: does your workplace (or school) have an AI-use policy about which data may go into which tool? If yes, summarize the relevant rule; if you can’t find one, say so.

Reflection: Have you ever done a personal-agent thing with data that should have stayed behind enterprise guardrails? No judgment — this is where most people slip. What will you change? Cross-reference Appendix C.

Reps 10–11: Cost, and the multi-agent future

Rep 10 — Feel the cost of the loop

An agent run triggers many model calls, not one. Take a task and estimate: roughly how many steps would an agent take (searches, page-reads, drafts)? Compare that to the one call a chatbot would make. Then, using the tier idea from Chapter 3, say which model tier you’d want for this agent and why (reserve the flagship tiers — the claude-opus-4-8 / gpt-5.5 class, mid-2026 — for the genuinely hard, multi-step reasoning; keep trivial loops cheap).

Reflection: Where does an agent’s cost most surprise a new user? (Hint: output tokens cost several times input, and the loop multiplies both.) Flag any figure as a “mid-2026 snapshot.”

Rep 11 — Sketch a two-agent workflow

On paper, design a tiny multi-agent workflow for a real output of yours: one agent researches, one drafts, and you are the manager who sets the goal, checks the handoff, and signs the result. Mark the exact point where the human sits.

Reflection: Where do the two agents’ errors most likely compound on each other, and which single human checkpoint would catch it before it reaches your neighbor (the client, boss, or customer who receives the work)?

Done? One Last Thing.

A miniature of Project 13, end to end. Pick one small, real, multi-step task you can safely delegate tonight (research three options and draft a comparison; triage and draft — but not send — a batch of replies; plan a small event). Then produce three things in a folder:

1. task-breakdown — the completed worksheet from code/task-breakdown.txt: goal, success criteria, green/yellow/red steps, gates, never-delegate list.
2. agent-log — the completed log from code/agent-log-template.txt: what you delegated, the plan it made, the steps and tools, every error you caught with its correction, and every point you intervened.
3. verdict — a short signed note: what you changed before you’d put your name on it, and your one-line accountability statement.

If you can supervise one delegation this cleanly tonight, you can do Project 13. That is the whole job in miniature: the agent does the labor, you gate the actions, you verify the output, you sign the account.

Up next: Project 13 — Project P13: Delegate to an Agent.