Learning objectives. Explain how a well-formed prompt evolves into an agent instruction; understand the additional elements an agent needs that a single prompt doesn't (persistent identity, tools, memory, permissions, escalation); and recognise the boundary between what this course covers and what the Holistic Agent course covers in full.

Why this matters

This is the module where this course deliberately opens the door it's been pointing at since the introduction, without walking all the way through it. A chatbot answers. An agent performs work. That distinction changes what "a good instruction" has to account for — and understanding the shape of that change, even before you build your first agent, makes everything in the companion manual click faster.

Plain-English explanation

Everything you've learned about writing a good prompt — a clear purpose, real context, explicit constraints, a defined output, a way to check the result — still applies to an agent. What changes is that an agent's instruction has to hold up not just for one response, but across many autonomous steps, potentially over hours or days, often without you reviewing every single action before it happens. A chatbot answers. An agent performs work. Work has consequences a single answer doesn't.

Core lesson

PLAIN ENGLISH — what a prompt has that an agent instruction needs more of

A one-off prompt needs a purpose, instructions, and constraints for this request. An agent instruction needs those same things stated so they hold up indefinitely, plus several things a single prompt never had to worry about:

Identity — who or what is this agent, consistently, across every interaction it has?
Persistent instructions — the standing rules that apply to every action it takes, not just this one
Tools — what it can actually do in the world, not just what it can say
Memory — what it should retain between separate runs, and what it shouldn't
Permissions — what it's actually allowed to touch, and what requires your approval first
Escalation — what it does when it hits something it shouldn't handle alone

PRACTITIONER — the same HPC-10 elements, under load

Nothing about HPC-10 stops applying to an agent — every element just has to be specified more rigorously, because a mistake compounds across many autonomous actions instead of showing up once and being immediately visible to you.

Purpose becomes a mission — stated as an outcome the agent is accountable for, not an activity, because it will make many small decisions in service of it without you checking each one.

Constraints become boundaries — explicitly, what the agent must refuse or hand to a human, because an agent that doesn't know its limits will confidently exceed them.

Context becomes something the agent has to assemble itself, correctly, at each step — this is exactly where Modules 5 and 7's context-engineering discipline stops being something you do once, manually, and becomes something the system has to do repeatedly, reliably, on its own.

Knowledge becomes the agent's durable knowledge base, exactly as in Module 9 — with the same "curated, not exhaustive" discipline, because an agent draws on it unattended, without you there to notice it's drowning in irrelevant material.

Resources become tools in the fuller sense: not just references, but capabilities the agent can actually invoke — look something up, send a message, update a record, exactly the territory the companion course's Tools, APIs and the Real World module covers in full. Module 6's structured-output principle matters enormously more here, because a tool call with the wrong shape doesn't just produce an awkward sentence — it can fail an action outright, or worse, half-succeed.

Evaluation and Verification stop being something you do occasionally and become something the system needs built in — because an agent making many autonomous decisions without a human checking each one needs its own checking mechanism. This is precisely why Module 11, immediately following this one, is not optional reading for anyone planning to move toward agents.

Iteration becomes a genuine feedback loop rather than a personal habit — what the agent got wrong needs to reach whoever maintains its instructions, systematically, not just be noticed once and forgotten.

ADVANCED — where this course stops and the Holistic Agent course starts

The Holistic Agent course's own framework, HAC-20 (Five Planes, Twenty Elements: Purpose, Cognition, Action, Governance, Evolution), is the full-scale version of exactly what this section has just walked through. Its Plane 1 (Purpose: Identity, Mission, Boundaries) is this module's Layer 1, made more rigorous. Its Plane 2 (Cognition: Context, Knowledge, Memory, Reasoning, Planning) is this course's Layer 2, plus genuine autonomy over multiple steps — see Agent Memory and Knowledge and Planning, Reasoning and Decision Making. Its Planes 3–5 (Action, Governance, Evolution) cover territory this course has deliberately not gone into: tools that change the real world (Agent Tools), permissions and security (Security, Governance and Control), human oversight design, and reliability engineering across repeated runs (Production Agent Systems).

That is not a gap in this course — it's the intended handoff. If you finish this course and want to actually build an agent, HAC-20 and the Holistic Agent course's Modules 1–3 — The New Age of AI, How Modern AI Actually Works, The Anatomy of an AI Agent — pick up exactly where this module leaves off, using vocabulary you already have.

Business example

A small firm's first attempt at "an AI agent" was really a well-written prompt run manually, once, each week — someone copy-pasted the week's data into a strong prompt (per Modules 2–3) and reviewed the output before sending it on. That's not a failure or a lesser approach — per this module's lesson, it's often the right level of sophistication: the task didn't need autonomy, memory across runs, or tool access, it needed a good prompt run consistently by a careful person. The firm's second project — automatically triaging inbound emails and drafting responses without someone manually copy-pasting each one — genuinely needed the fuller agent treatment (persistent instructions, defined escalation, tool access to actually send drafts for review), and that's where they picked up the Holistic Agent course.

Practical exercise — design an agent instruction set

Take a task you currently do repeatedly with a well-structured prompt (built across this course's earlier exercises). Sketch what it would need to become a genuine agent instruction: what's its identity and mission stated as an outcome? What tools would it actually need, beyond just producing text? What should it never do without your approval? What should it do when it's unsure? You are not building this agent yet — you're testing whether you can specify one clearly, which is the actual skill this module teaches.

Common mistakes

Calling a manually-run, well-written prompt "an agent" — it's still a prompt, run by a person, and that's often exactly the right tool (Module 1's warning, returning here with more weight).
Under-specifying boundaries, assuming "it'll figure out what not to do" the way a careful person might.
Treating memory as automatically good — an agent that remembers everything indefinitely, without review, accumulates errors the same way a system prompt accumulates rules (Module 7).
Skipping ahead to build an agent before the evaluation discipline in Module 11 is in place — this is precisely backwards, and the Holistic Agent course makes the same point about evaluation coming before agents, not after.

Expert insight

The transition from prompt to agent instruction is not a jump in cleverness. It's a jump in what has to be true reliably, without you checking. Everything this course has taught about context, grounding, output specification, and verification was always in service of that same goal — an agent instruction just can't get away with any of it being implicit anymore.

Knowledge check

In one sentence, what's the practical difference between a chatbot and an agent?
Which HPC-10 elements need to become more rigorous for an agent, and why specifically?
What does "boundaries" mean for an agent, and why do they matter more than for a single prompt?
Name the five planes of HAC-20 and match each to the closest HPC-10 layer or concept from this course.
Why is evaluation discipline (Module 11) a prerequisite for building an agent, not an optional add-on afterward?

Module summary

An agent instruction is everything this course has taught about writing a good request, made rigorous enough to hold up across many autonomous actions without your review of each one. Identity, persistent instructions, tools, memory, permissions, and escalation are the genuinely new elements — and HAC-20, the Holistic Agent course's own framework, is where this course's vocabulary continues at full scale.

Further exploration

The Holistic Agent course, Modules 1–3 — The New Age of AI, How Modern AI Actually Works, and The Anatomy of an AI Agent — the natural next reading after this module.

Prompt Engineering for AI Agents