D1 · What an Agent Is and When to Use One

This domain is worth 16% of the material — roughly 8 of 50 items on our mock. It tests one judgment above all others: given a piece of work, is the right tool a single prompt, a repeatable workflow, or a delegated agent — and when is an agent actively the wrong answer? The Academy course opens here because most delegation failures are chosen before a brief is ever written: someone reached for an agent when a workflow would have been safer, cheaper and easier to verify.

What you need to know

A prompt is a single request you supervise turn by turn. A workflow is a repeatable sequence of prompting steps with defined inputs, outputs and review points, still driven by you. An agent is given an objective and the autonomy to plan, use tools and take multiple steps toward it with limited supervision. The four axes that separate them are autonomy (how much it decides for itself), tool access (what it can touch), duration (how long it runs unsupervised) and reversibility (how hard its actions are to undo). An agent is the right choice when a task is genuinely multi-step, benefits from tool use, and is worth the cost of setting boundaries and verifying unwatched work. It is the wrong choice when the task is trivial, when you cannot specify a clear definition of done, or when the actions are irreversible and cannot be gated.

Learning objectives

By the end of this page you should be able to:

1. Distinguish a prompt, a workflow and an agent on autonomy, tool access, duration and reversibility.
2. Decide which of the three fits a given task, and justify the choice against those axes.
3. Recognise the situations where an agent is the wrong tool and a workflow or a single prompt is safer.
4. Describe what “human oversight” means for an agent versus for a workflow.
5. Estimate the setup and verification cost an agent adds, and weigh it against the work it saves.

1.1 The three modes of working with AI

The whole domain rests on one distinction. Read the axes, not the labels: the same task can be a prompt today and an agent tomorrow depending on how much you hand off.

        autonomy ▲
                 │                              ┌──────────┐
            high │                              │  AGENT   │  goal in, plans + acts,
                 │                              └──────────┘  uses tools, runs unwatched
                 │              ┌────────────┐
          medium │              │  WORKFLOW  │  you sequence steps + review points
                 │              └────────────┘
                 │  ┌────────┐
             low │  │ PROMPT │  one request, you supervise the turn
                 │  └────────┘
                 └──────────────────────────────────────────►
                        tool access + duration + blast radius

1.2 Autonomy: who chooses the next step

Autonomy is the axis people misjudge most. A long, detailed prompt is still low-autonomy if you decide what happens next. Autonomy is about who chooses the path, not how big the request is.

An agent earns its keep exactly when the path cannot be scripted in advance — when step three depends on what step two discovered. If you already know every step, a workflow is cheaper to build and far easier to verify.

1.3 Tool access: capability and blast radius are the same thing

An agent is only as powerful as the tools it can reach, and only as dangerous. Every connector, search tool or file action you grant increases both what it can accomplish and what it can break.

The rule this domain teaches, and D3 develops: grant the least access that lets the work succeed. A summariser needs read, not write. A research agent needs search, not send.

1.4 Duration and unwatched work

Duration changes the problem qualitatively, not just quantitatively. A ten-second prompt you watch is self-correcting — you see a wrong turn and stop it. A twenty-minute agent run is not: by the time you look, it has already taken the steps.

watched work                          unwatched work
──────────────                        ────────────────
you see each step        │            you see a plan, then a result
you can stop instantly   │            you can only stop at checkpoints
errors caught live       │            errors caught by verification after
trust = observation      │            trust = evidence trail + spot-checks

This is why longer autonomy demands the boundaries of D4 and the verification of D5. The moment work runs unwatched, “I’ll notice if it goes wrong” stops being a control.

1.5 Reversibility: the axis that decides how careful to be

Reversibility is the single most important axis for judging risk. It does not decide whether to use an agent — it decides how much of D4 (boundaries) and D5 (review) you must add before you do.

1.6 When an agent is the wrong answer

The course is refreshingly honest that agents are frequently the wrong tool. Reaching for one when a workflow would do is the classic beginner mistake, because agents cost more to set up, cost more to run, and are harder to verify.

An agent is the wrong tool when:

• The task is trivial or one-shot — a single rewrite, one lookup, one calculation. A prompt is faster.
• The steps are fully known and fixed — a documented workflow is cheaper to build and trivial to verify.
• You cannot state a clear definition of done — an agent given a fuzzy goal will produce fuzzy work and you will not be able to tell if it succeeded.
• The actions are irreversible and cannot be gated — if you cannot put an approval checkpoint before the dangerous step, do not automate it.
• Verification would cost more than the work — if checking the unwatched output takes longer than doing the task yourself, delegation is a net loss.
• The task needs judgment you cannot specify — nuanced tone, sensitive stakeholder calls, anything where “you’ll know it when you see it” is the real acceptance test.

Should I use an agent?
│
├─ Is it one step I'll watch?              ── yes ─► PROMPT
├─ Are the steps fixed and known?          ── yes ─► WORKFLOW
├─ Can I state a clear "done"?             ── no  ─► not yet: sharpen the objective (D2)
├─ Are irreversible actions gate-able?     ── no  ─► don't automate the dangerous step
└─ otherwise                                        ─► AGENT, with boundaries + verification

1.7 What “oversight” means at each level

Human oversight is not one thing. Its shape changes with autonomy, and matching the wrong kind of oversight to the mode is a common trap.

The mistake is assuming an agent can be supervised the way a prompt is — by watching. You cannot watch a long unwatched run; you can only bound it and check it.

Decision framework

Use the PADR test to place any task before you build anything. Score each axis, and the highest-demanding axis usually decides the mode.

How to read it: if every axis lands in the Prompt column, do not build a workflow. If Path is “fixed” but you are tempted by an agent, build the workflow — it is cheaper and more verifiable. Only when Path is “must plan” and Access is “a tool set it uses itself” does an agent clearly win, and then R tells you how many boundaries to add before you let it run.

Common mistakes

Scenario challenge

Scenario. Priya leads operations at a mid-size firm on ChatGPT Work. Every Monday she compiles a supplier-status report: she pulls the latest delivery figures from a shared spreadsheet, checks three supplier portals for open issues, drafts a one-page summary, and emails it to the leadership list. It takes her about ninety minutes and the steps are the same every week. A colleague suggests she “build an agent to just do the whole thing and send it”. Priya is tempted — the sending is the part she most wants off her plate.

Expert reasoning trace.

1. Run the PADR test, not the enthusiasm. Path: the steps are identical every week — that is a fixed path, which points to a workflow, not an agent. Access: it needs to read a spreadsheet and read three portals, and to send an email. Duration: a few minutes, and she could watch it. Reversibility: the email to leadership is irreversible and external — the highest-risk axis in the whole task.
2. Separate the reversible bulk from the irreversible tail. Pulling figures, checking portals and drafting the summary are all reversible read-and-draft work — safe to automate. Sending to leadership is the one irreversible step, and it is exactly the step she wanted to hand off.
3. Resist “one agent that sends it”. The temptation is to automate end to end, but the send is where blast radius lives. A wrong figure emailed to leadership cannot be recalled.
4. Choose the mode per axis. Because the path is fixed, the right build is a workflow with review points — cheaper and far easier to verify than an agent. If she later wants more autonomy (e.g., it decides which portals to check based on which suppliers are active), it becomes an agent — but even then the send stays behind an approval gate.
5. Design the gate. The workflow drafts the email and pauses; Priya reviews the one-page summary and the figures, then approves the send. She has moved the ninety minutes of assembly off her plate while keeping the two-minute judgment — the review and the send — where it belongs.

The point. The task did not need an agent; it needed a workflow with a human gate on the one irreversible step. Reaching for an agent “because it’s more powerful” would have added setup and verification cost for no benefit, and automating the send outright would have removed the only control that mattered.

Assessment traps

Practice questions

Each item states how many responses to select. Attempt before revealing.

Key takeaways

• Prompt, workflow and agent differ on four axes: autonomy, tool access, duration and reversibility — not on difficulty or prompt length.
• Autonomy is who chooses the next step. A long prompt is still low-autonomy if you decide what happens next.
• Use an agent when the path can’t be scripted in advance and it needs to use tools over an unwatched run; use a workflow when the steps are fixed.
• Reversibility decides how many boundaries and how much verification you must add, not whether you may use an agent.
• An agent is the wrong tool for trivial tasks, fully-known steps, fuzzy goals, un-gateable irreversible actions, and cases where verification costs more than the work.
• Grant the least tool access the work needs; every added tool is added blast radius.
• Oversight for an agent is designed in (boundaries plus verification), not applied by watching a long unwatched run.