Course Curriculum
Forty Hours. Five Days. One Working Agent.
The CAAP certification course is delivered as a lab-based build program. Every learning unit pairs instruction with supervised lab time, and the labs are not throwaway exercises: from the first day, each candidate works on one multi-step agent that is built, evaluated and documented across the course. That same build becomes the assessed project, covering tool use, memory design, observability, safety controls and a deployment plan.
Duration
40 contact hours delivered across 5 days
Format
Lab-based build program; instruction paired with hands-on lab time on the candidate's own agent build
Assessment
Examination (40%) and an applied agentic build project (60%)
Entry Profile
Practitioners who build and operate agentic systems; working programming or automation experience recommended
Course-Level Learning Objectives
What the Course Certifies You Can Do.
On completion, candidates are able to:
- Build a multi-step agent that plans a task, calls tools through well-defined contracts and completes work end to end.Traces to LU1
- Orchestrate multi-step and multi-agent workflows, and justify when orchestration is warranted over a simpler deterministic pipeline.Traces to LU1
- Design an agent's context and memory architecture across short-term, long-term and episodic stores so it stays grounded over long tasks.Traces to LU2
- Instrument an agent with tracing, structured logging and evaluation suites that measure quality objectively before and after deployment.Traces to LU3
- Harden an agent against known failure modes, including runaway loops, hallucinated tool calls and cost runaways, with layered controls tested adversarially.Traces to LU4
- Deploy an agent through a staged rollout, with authentication, state handling and integration into existing systems.Traces to LU5
- Optimize the token spend and latency of a working agent and prove the gain with before-and-after measurements.Traces to LU6
- Document the complete build as an operations-ready pack covering architecture, evaluation results, safety controls and a deployment plan.Traces to LU1 to LU6 via the build project
Learning Units
Six Learning Units, One per Competency Domain.
Each learning unit maps directly to one CAAP competency domain and is specified as numbered learning outcomes with assessment criteria first, then the Attitude, Skills and Knowledge (A.S.K.) statements that instructors teach to and assessors score against. Each unit also states its delivery method and the course-level objectives it supports. Build-heavy units carry more contact hours.
LU1Agent Frameworks, Orchestration & Tool Use
9 Contact Hours
Delivery: Guided build lab; instructor demonstration followed by supervised lab time on the candidate's own agent loop and tool contracts. Supports: CLO1, CLO2 and CLO8.
Learning Outcomes
- LO 1.1Build a working agent loop, using a framework or model APIs directly, and defend the architectural choice.
Assessment criteria:
- Builds an agent loop that plans, acts and observes across a multi-step task and completes it without manual intervention
- States the reasons for the chosen framework or direct API approach, naming at least one rejected alternative and why it was rejected
- LO 1.2Define tool and function-calling contracts with typed schemas, explicit error returns and input validation.
Assessment criteria:
- Defines every tool with a typed schema, input validation and an explicit error return, so malformed calls fail visibly rather than silently
- Implements tool calls whose input and output contracts are validated before the agent acts on results, with failures logged and retried within a bounded policy
- LO 1.3Orchestrate a multi-step or multi-agent workflow and identify when a plain pipeline is the better design.
Assessment criteria:
- Decomposes a task into orchestrated steps or sub-agents using a named pattern, and the workflow completes under test
- Identifies at least one part of the build where a deterministic pipeline replaces agent reasoning, with the simplification justified
| A.S.K. Dimension | Statements |
|---|
| Attitude |
- Bias toward the simplest architecture that meets the requirement; orchestration must earn its complexity
- Test-before-trust discipline on every tool integration, no tool goes live on the happy path alone
|
| Skills |
- Implement an agent loop (plan, act, observe) with a current agent framework or directly on model APIs
- Write JSON Schema tool definitions with strict input validation and useful error surfaces
- Wire an agent to external APIs and local functions, handling auth, timeouts and retries at the tool boundary
- Decompose a task into orchestrated steps or sub-agents (sequential, parallel fan-out, router, evaluator loop)
- Debug malformed or unexpected tool calls from raw model output and traces
|
| Knowledge |
- Agent architectures: single loop, planner-executor, multi-agent and their trade-offs
- Anatomy of a function-calling contract: name, description, parameter schema, return shape, error surface
- Orchestration patterns and the failure characteristics of each
- When a deterministic pipeline outperforms an agent, and how to tell before building
|
LU2Context Engineering & Memory Design
7 Contact Hours
Delivery: Guided build lab with a code review clinic; memory designs are reviewed against traces from the candidate's own build. Supports: CLO3 and CLO8.
Learning Outcomes
- LO 2.1Design a context strategy for an agent: what enters the window, in what structure, and what gets compacted or evicted.
Assessment criteria:
- Documents what enters the context window, in what order and structure, and what is compacted or evicted as the task grows
- Demonstrates the agent staying on task across a run long enough to force compaction or eviction, verified from traces
- LO 2.2Implement short-term, long-term and episodic memory, selecting storage and retrieval appropriate to each.
Assessment criteria:
- Implements short-term, long-term and episodic memory with storage and retrieval choices matched to each, and the agent recalls prior-run information correctly
- Diagnoses an induced context failure, such as stale or conflicting memory, from traces and corrects it at the design level rather than by re-prompting
| A.S.K. Dimension | Statements |
|---|
| Attitude |
- Treat the context window as a scarce budget to be spent deliberately, not a bin to be filled
- Skepticism toward "just add more context" as a fix; diagnose the failure before feeding the window
|
| Skills |
- Structure system prompts, retrieved passages and tool results so the agent stays grounded on the task
- Implement retrieval into the agent loop with sensible chunking and relevance filtering
- Build long-term memory using summarization and compaction so state survives beyond a single window
- Design episodic memory that lets an agent recall and learn from prior runs
- Diagnose context failures (truncation, distraction, stale or conflicting memory) systematically from traces
|
| Knowledge |
- Context window mechanics, positional effects and degradation over long inputs
- Memory taxonomy: short-term working context, long-term stores, episodic recall, and what belongs in each
- Retrieval patterns and chunking trade-offs for agent workloads
- Compaction and summarization strategies and what they lose
- The failure signatures of poor context design and how they present in output
|
LU3Evaluation, Monitoring & Observability
7 Contact Hours
Delivery: Evaluation harness workshop; candidates assemble datasets, rubrics and tracing on their own build under instructor supervision. Supports: CLO4 and CLO8.
Learning Outcomes
- LO 3.1Build an evaluation suite for a non-deterministic system, with a purpose-built dataset, rubric scoring and pass thresholds.
Assessment criteria:
- Assembles an evaluation dataset of real and constructed cases with a scoring rubric and explicit pass thresholds
- Runs the suite against the build and reports results that reproduce within a stated tolerance on a repeat run
- LO 3.2Instrument an agent with tracing and structured logging so any failure can be attributed to a specific step.
Assessment criteria:
- Emits traces covering every step, tool call and token count so a failed run can be attributed to a specific step from the trace alone
- Locates the cause of a seeded failure using traces and logs only, without re-running the agent
- LO 3.3Detect and quantify regressions when models, prompts or tools change.
Assessment criteria:
- Detects a quality regression introduced by a model, prompt or tool change by comparing evaluation results before and after
- Quantifies the regression against the suite's pass thresholds and states whether the change should ship
| A.S.K. Dimension | Statements |
|---|
| Attitude |
- Nothing ships on vibes: a quality claim without an evaluation result is an opinion
- Treat every evaluation result as provisional until it reproduces
|
| Skills |
- Assemble evaluation datasets from real transcripts and constructed edge cases
- Write scoring rubrics and combine programmatic checks with model-graded scoring
- Emit traces that span the full run: steps, tool calls, tokens and intermediate state
- Set up monitoring and alerts for quality drift and behavioral change in production
- Run before-and-after regression comparisons across model, prompt and tool versions
|
| Knowledge |
- Evaluation types: exact match, programmatic checks, rubric-based and model-graded scoring
- Dataset design for non-deterministic outputs, including inter-rater agreement and grader calibration
- Tracing concepts: spans, run trees, metadata and correlation across steps
- Production monitoring signals specific to agents, beyond standard application metrics
- Regression testing discipline for systems whose outputs vary run to run
|
LU4Safety Controls & Failure-Mode Design
6 Contact Hours
Delivery: Red-team exercise; candidates attack each other's builds in pairs, then implement and retest controls on their own. Supports: CLO5 and CLO8.
Learning Outcomes
- LO 4.1Enumerate the failure modes of a given agent and design a layered control for each.
Assessment criteria:
- Produces a failure-mode inventory for the build covering runaway loops, hallucinated tool calls, cost runaways, prompt injection and data leakage
- Implements a layered control for each inventoried failure mode, including permission boundaries, validation gates, loop limits and human escalation where impact is high
- LO 4.2Test controls adversarially and document the residual risk honestly.
Assessment criteria:
- Attacks the build's own controls with documented adversarial tests, including at least one prompt-injection attempt against a live tool path
- Records residual risk for each control, distinguishing tested behavior from assumed behavior
| A.S.K. Dimension | Statements |
|---|
| Attitude |
- Assume the agent will misbehave; design for the failure, not the demo
- Adversarial mindset toward one's own build: attack it before anyone else can
- Honesty about residual risk; a control that was never tested is a hope, not a control
|
| Skills |
- Implement permission boundaries and least-privilege tool access for each agent capability
- Add input and output checks, including schema validation gates on tool arguments
- Set loop limits, budget caps and rate limits that halt runaway executions
- Design human-escalation checkpoints for irreversible or high-impact actions
- Red-team an agent for prompt injection, hallucinated tool calls and data exfiltration paths
|
| Knowledge |
- The agent failure taxonomy: infinite loops, hallucinated tool calls, cost runaways, prompt injection, data leakage
- Sandboxing and isolation options for agent execution environments
- Guardrail placement: before the model, after the model, and around each tool
- Escalation and approval patterns, and where a human belongs in the loop
- Incident response and rollback basics for agentic systems
|
LU5Deployment Patterns & Integration
6 Contact Hours
Delivery: Deployment planning studio; candidates stage their own build toward a production-like deployment and defend the rollout plan. Supports: CLO6 and CLO8.
Learning Outcomes
- LO 5.1Take an agent from local prototype to a production-like deployment through defined stages.
Assessment criteria:
- Moves the build through defined stages toward a production-like deployment, with configuration separated from code and secrets held outside the codebase
- Produces a staged rollout plan with explicit gate evidence and rollback triggers for each stage
- LO 5.2Integrate an agent with existing systems, handling authentication, state and error recovery.
Assessment criteria:
- Integrates the agent with at least one existing system or API, handling authentication with correctly scoped credentials
- Demonstrates state persistence and error recovery: an interrupted run resumes rather than restarting, and integration failures degrade gracefully
| A.S.K. Dimension | Statements |
|---|
| Attitude |
- Production readiness is earned in stages, not declared at the end
- Respect for the systems the agent touches: an integration failure is the agent's failure
|
| Skills |
- Package an agent as a service behind an API, with configuration separated from code
- Manage credentials and secrets outside the codebase and scope them to what the agent needs
- Persist and recover run state so interrupted work resumes instead of restarting
- Design a staged rollout (shadow, canary, gated release) with explicit rollback triggers
- Integrate agent endpoints into an existing application flow with graceful degradation on failure
|
| Knowledge |
- Deployment topologies: request-response service, background worker, scheduled job, event-driven
- Staged rollout patterns and the evidence required to pass each gate
- State and session handling for long-running agent tasks
- Authentication patterns for agents acting with delegated permissions
- Reliability and latency considerations that shape the deployment choice
|
LU6Cost & Performance Optimization
5 Contact Hours
Delivery: Measurement-led optimization lab; candidates profile their own build, apply optimizations and verify gains against the evaluation suite. Supports: CLO7 and CLO8.
Learning Outcomes
- LO 6.1Profile the token spend and latency of a working agent and identify the dominant cost drivers.
Assessment criteria:
- Profiles per-run token spend and latency broken down by step and tool call, and names the dominant cost drivers with figures
- Presents the profile as a baseline measurement suitable for before-and-after comparison
- LO 6.2Apply optimizations such as model routing, caching and prompt slimming, and prove the gain with measurements.
Assessment criteria:
- Applies at least two optimizations, such as model routing, caching or prompt slimming, and proves the gain with before-and-after measurements
- Re-runs the evaluation suite after optimization and shows quality held within the suite's pass thresholds
| A.S.K. Dimension | Statements |
|---|
| Attitude |
- Cost-consciousness as a design input from day one, not an afterthought before launch
- Refusal to claim an optimization gain without a before-and-after measurement
|
| Skills |
- Measure per-run token usage and latency, broken down by step and tool call
- Route each step to the cheapest model that meets its quality bar
- Apply prompt caching and response reuse where inputs repeat
- Trim prompts and tool outputs without measurable quality loss
- Re-run the evaluation suite after each optimization to confirm quality held
|
| Knowledge |
- Token pricing mechanics and the dominant cost drivers inside agent loops
- Model-tier selection criteria for routing decisions
- Caching options, their hit conditions and their invalidation risks
- Latency budgets and the effect of serial versus parallel calls
- The cost, quality and latency trade-off and how to present it to stakeholders
|
Assessment Blueprint
How Each Learning Unit Is Assessed.
The examination samples knowledge and judgment across all six learning units and carries 40% of the final mark. The applied agentic build project carries 60%: one working multi-step agent, built, evaluated and documented across the course, covering tool use, memory design, observability, safety controls and a deployment plan. Both components are scored against the competency framework, and certification decisions are made independently by the AICA Certification and Standards Authority.
| Learning Unit | Examination Evidence | Build Project Evidence | Weighting |
|---|
| LU1 Agent frameworks, orchestration & tool use | Framework selection reasoning, orchestration patterns, tool contract design | Working agent loop with typed tool contracts and orchestrated steps | Exam 8%
Project 12% |
| LU2 Context engineering & memory design | Context window mechanics, memory taxonomy, retrieval trade-offs | Implemented memory design across short-term, long-term and episodic stores | Exam 7%
Project 10% |
| LU3 Evaluation, monitoring & observability | Evaluation methods for non-deterministic systems, tracing concepts | Evaluation dataset, rubric scores and end-to-end traces for the build | Exam 7%
Project 12% |
| LU4 Safety controls & failure-mode design | Failure taxonomy, guardrail placement, escalation patterns | Implemented safety controls with documented adversarial tests | Exam 7%
Project 11% |
| LU5 Deployment patterns & integration | Deployment topologies, staged rollout, authentication patterns | Deployment plan with staged rollout and rollback triggers | Exam 6%
Project 9% |
| LU6 Cost & performance optimization | Cost drivers, model routing, caching strategies | Before-and-after cost and latency measurements, quality held | Exam 5%
Project 6% |
| Total | Examination 40% | Build project 60% | 100% |
Weightings are indicative of emphasis across the two assessment components and sum to the published 40% examination and 60% build project split. The build project is assessed as one integrated system; the evidence column shows which parts of that system each learning unit's scoring draws on.
Credential Terms
Validity, Renewal and Candidate Policies.
The CAAP credential is governed by the same published terms as every AICA certification. The provisions below apply to all candidates and credential holders.
| Term | Provision |
|---|
| Credential validity | 3 years from award date |
| Renewal | Via Continuing Professional Development: 45 CPD hours per 3-year cycle, logged with AICA |
| Retake | Reattempt after a 14-day waiting period; maximum 3 attempts in any 12 months |
| Appeals | To AICA's Certification and Standards Authority |
| Proctoring | Examinations are proctored, online or center-based through Authorized Training Partners |
| Conduct | Certification requires agreement to the AICA Code of Professional Conduct |
Curriculum Standard v1.0. Published 10 July 2026. Reviewed annually by the AICA Certification and Standards Authority.