Agents and Workflows – Track Overview

Agents track 6 domains 50-item mocks Foundations pathway · course 3

This track is independent preparation for the OpenAI Academy course Agents and Workflows, the third and final course in the Foundations pathway (after AI Foundations and Applied AI Foundations). It is not an official OpenAI course and not an official assessment; see the credential landscape for how Academy badges differ from certifications. The material here is built from publicly available OpenAI learning objectives.

What this track prepares you for

The Academy course Agents and Workflows runs 75–90 minutes, its product focus is ChatGPT Work, and its published objectives are to define tasks, context, boundaries and checkpoints, then review and improve results. The course is about delegating structured work to an agent with human oversight — deciding what to hand off, briefing it well, setting the limits it must operate inside, and verifying what comes back.

This is a non-developer track. It teaches how to delegate work to agents inside ChatGPT Work and Codex-style surfaces as a knowledge worker, not how to build agents in code. If you want the builder’s view — the Responses API, the Agents SDK and the Agents API — take the API Developer Path instead. The two tracks share vocabulary but answer different questions: this one asks should I delegate this, and how do I brief and check it; the API track asks how do I construct the runtime.

Blueprint

Our mock exams and domain pages follow this weighting. Item counts are approximate on a 50-item mock.

#	Domain	Weight	Items (approx.)	Page
1	What an Agent Is and When to Use One	16%	~8	D1
2	Defining Objectives and Tasks	18%	~9	D2
3	Context, Tools and Permissions	18%	~9	D3
4	Boundaries and Guardrails	16%	~8	D4
5	Reviewing and Verifying Agent Work	16%	~8	D5
6	Reliability and Iteration	16%	~8	D6

The mindset this track rewards

Delegating to an agent is management, not prompting. The correct answers on this material consistently reflect the posture of a good manager handing work to a capable but literal new hire who will not ask for missing information and will not stop at a boundary you did not set:

• Specify the outcome, not the keystrokes. A good brief names the goal, the definition of done, the constraints and the sources of truth — then trusts the agent to find the path.
• Give the least access that lets the work succeed. More tools and broader permissions are more capability and more blast radius. Start narrow.
• Put the gate before the irreversible step, not after. An agent that can send, publish, pay or delete needs an approval checkpoint the system enforces, not one it merely promises to respect.
• Verify the artefact, not the confidence. You did not watch the run; trust the evidence trail and spot-checks, never a fluent summary of what the agent claims it did.
• Treat a failed delegation as a brief defect first. Before blaming the model, ask what the brief left ambiguous, what context was missing, and which checkpoint would have caught it.

Wrong answers reliably do the opposite: hand off an ambiguous goal, grant broad access “to be safe”, trust a confident completion summary, and re-run the same vague brief hoping for a better result.

Suggested time allocation

A focused plan of roughly 14 hours, weighted by domain weight and by how much judgment each domain demands.

Domain	Weight	Hours
Defining Objectives and Tasks	18%	3
Context, Tools and Permissions	18%	3
What an Agent Is and When to Use One	16%	2
Boundaries and Guardrails	16%	2
Reviewing and Verifying Agent Work	16%	2
Reliability and Iteration	16%	2

Hands-on preparation checklist

Do these in a real ChatGPT Work environment (or the closest surface your plan allows). Reading about delegation teaches you nothing about delegation.

• Take one recurring task you currently do by hand and write a delegation brief for it: goal, definition of done, constraints, sources of truth, checkpoints.
• Run the same task twice — once with a vague one-line prompt, once with the full brief — and compare how much rework each needs.
• Give an agent a task that requires a connector or uploaded document, then remove that context and watch where it guesses.
• Deliberately set an approval checkpoint before an action that leaves the workspace (an email draft, a shared file) and confirm the agent pauses.
• Delegate a multi-step task, then verify the result without re-reading everything: pick two claims and reproduce them from the evidence trail.
• Catch a silent partial completion — ask for five outputs, check whether you actually got five that meet the definition of done.
• Take a delegation that went wrong and rewrite the brief once, classifying the failure (misunderstood objective, missing context, wrong tool, partial completion, drift) before you change anything.
• Review a long agent run efficiently: read the plan, the checkpoints and the artefacts rather than the full transcript, and note what you would have missed.

Track pages