Six phases, grouping the exam's ten domains by weight and by the dependencies the source material names on its own. Every phase tells you how the exam questions that material, gives you a practice exercise, and ends with self-checks you should be able to answer without notes.
To study for the NVIDIA NCP-AAI certification, work through the ten domains in six weighted phases rather than the order they are listed. Start with Agent Architecture and Design and Agent Development (15% each, tied for the largest), covering agent architecture styles, the ReAct loop, multi-agent orchestration topologies, and the Retry and Circuit Breaker resilience patterns. Move to Cognition, Planning, and Memory and Knowledge Integration and Data Handling (10% each), covering the agent memory taxonomy, the five planning directions, and the RAG pipeline including GraphRAG, HybridRAG, and agentic RAG. Then Evaluation and Tuning and Run, Monitor, and Maintain (13% and 5%), which together cover evaluation pipelines, profiling, and continuous production monitoring. Continue with Deployment and Scaling and NVIDIA Platform Implementation (13% and 7%), covering NIM, TensorRT-LLM, Triton, and the NeMo Agent Toolkit. Finish with Safety, Ethics, and Compliance and Human-AI Interaction and Oversight (5% each), covering NeMo Guardrails' five rail stages and human-in-the-loop oversight. Build one working agent early and extend it through every phase, since architecture, resilience, memory, retrieval, evaluation, deployment, and safety all attach to the same system. Most candidates with 1–2 years of applied AI/ML experience need 40 to 60 hours of focused study.
Study time should follow exam weight. The five domains and their share of the marks, heaviest first — this is the order the six phases below follow.
The foundational structuring of agentic AI systems: how an agent perceives, reasons, acts, remembers, and communicates, and how multiple agents cooperate.
The hands-on build: prompt chains, multimodal model integration, custom tools, and — the part that separates a demo from production — resilience against transient and persistent failures.
Proving an agent works and then making it better: evaluation pipelines and benchmarks, structured feedback, and tuning against the accuracy-versus-latency trade-off.
Taking an agent from a laptop to production: containerized multi-agent deployment, MLOps governance, profiling under load, and balancing cost against availability.
How an agent thinks: the memory taxonomy, reasoning frameworks, planning strategies for multi-step decisions, and adapting from experience.
Feeding an agent trusted external knowledge: the canonical RAG pipeline, vector databases, ETL and data quality, and reasoning over mixed structured and unstructured sources.
The NVIDIA-specific domain: using the NeMo Agent Toolkit, NIM, NeMo Guardrails, TensorRT-LLM, and Triton together to build and accelerate agentic systems.
Keeping a deployed agent healthy: monitoring dashboards, logs and per-step tracing for root-cause diagnosis, continuous benchmarking, and automated tuning and versioning.
Making an agent responsible: system security and audit trails, compliance guardrails, bias and toxicity mitigation, layered safety, and licensing and regulatory compliance.
Keeping humans in control: intuitive user-in-the-loop interfaces, structured feedback loops, transparency mechanisms, and human oversight and intervention points.
Each phase names the domains it covers, how the exam questions that material, a practice exercise, and the self-checks that tell you whether to move on.
Be able to choose an agent architecture style, implement the ReAct loop, and pick the right multi-agent topology and memory layout for a stated scenario.
A short design document for one agent: its architecture style, memory layout, and orchestration topology, defended against a stated scenario.
Build a tool-calling agent and wrap every external call in resilience logic that survives a transient fault without amplifying a real outage.
A tool-calling agent with retry and circuit-breaker logic around one external call, tested against an injected failure.
Design the agent's memory and planning, then ground it in an external knowledge source it does not have in its weights.
A memory-and-planning design for one agent, driving a working RAG pipeline that grounds it in an external document set.
Prove an agent works with a repeatable evaluation pipeline, keep it separate from profiling, and carry that same discipline into live monitoring after launch.
An evaluation pipeline and a profiler trace for the same agent, kept as two separate artifacts, plus one monitoring dashboard sketch for it in production.
Deploy an agent on NVIDIA's own serving stack and scale it without confusing what each platform component actually does.
A deployment plan for one agent naming which NVIDIA component does which job, plus a measured cost-versus-availability tradeoff at a stated load.
Attach a concrete control to every safety and oversight principle, so you can name the mechanism and the point where a human can step in.
A one-page safety-and-oversight checklist for one agent: each principle, the control that implements it, and the point where a human can intervene.
The same six phases on a calendar, at three intensities. Pick the one that matches the time you actually have — total hours matter less than leaving the judgement-shaped material time to settle.
You already build agentic systems and need the credential soon. Assumes two to three hours on weekdays and a full day each weekend.
The default recommendation. Around eight hours a week leaves room for the material to settle, which matters for the scenario-shaped questions this exam favors.
You have LLM fundamentals but have not built an agent before. The extra weeks go on Phases 1 through 3, where the new material concentrates.
Everything the plan covers, grouped by domain. Titles that link are published guides; the rest are on the way.
15% · 6 topics · 1 published
NVIDIA's glossary names four multi-agent orchestration topologies — centralized, decentralized, federated, and hierarchical — and the choice between them, not the number of agents, is what determines a system's coordination cost, failure mode, and blast radius when something goes wrong.
15% · 5 topics · 1 published
Retry and Circuit Breaker are two distinct resilience mechanisms for the same underlying problem — a failing dependency — and the exam's most-tested trap is treating them as interchangeable: Retry reattempts a transient fault (immediately for rare blips, after backoff for busy/connectivity faults, never without idempotency), while the Circuit Breaker is a three-state machine (Closed → Open → Half-Open) that stops calling a persistently failing dependency so it gets room to recover.
13% · 5 topics
The most testable distinction in this domain.
13% · 5 topics
10% · 4 topics
Decomposition is one of five, not the whole answer.
10% · 4 topics
7% · 4 topics
5% · 4 topics
5% · 4 topics
Input, dialog, retrieval, execution, output.
5% · 4 topics
How people waste weeks preparing for this exam, and what to do instead. These are process errors rather than gaps in the material.
Follow weight and dependency instead. Agent Architecture and Design is tied for the largest domain and its vocabulary — memory, orchestration, ReAct — is assumed everywhere else.
Prepare for scenario judgment, not recall. Every domain's own source material carries the same warning: you are expected to reason about why an architecture or pattern fits a scenario, not define it.
Drill them as a pair with a clear boundary: retry reattempts a transient fault, the breaker stops calling a persistently failing one. Rehearse the breaker's three states by name until Half-Open is automatic.
Give each a focused session. Together they are 15% of the exam, and each has one or two facts — the five NeMo Guardrails rail stages, the EU AI Act's Article 14 — that alone cover most of what gets asked.
Write one sentence per tool: toolkit orchestrates, NIM serves, TensorRT-LLM optimizes, Triton hosts, Guardrails constrains. The exam bait-and-switches between them constantly.
Learn all five planning directions — Task Decomposition, Plan Selection, External Module, Reflection, Memory — since Reflection and Plan Selection are common distractor-versus-correct pairs.
Learn the drawbacks with equal weight: added cost and latency, reviewer inconsistency, and privacy exposure are all named, tested concerns.
Technique rather than content — how to spend the hour, how to handle the questions that give no partial credit, and how to know when you are ready.
The paper can run to 70 questions in 120 minutes, so a little over 90 seconds each is the pace to rehearse. Flag anything still unresolved at two minutes and move on.
Scenario questions name a constraint — latency, cost, availability, a specific failure type. Two options are usually right for the general subject and wrong for the stated constraint. Find the constraint clause first.
Retry fires on a transient fault; the circuit breaker fires on a persistent one. Knowing the definitions is not the same as knowing which condition in a scenario calls for which — practice classifying the fault first.
Toolkit orchestrates, NIM serves, TensorRT-LLM optimizes, Triton hosts, Guardrails constrains, a vector database indexes. One clear sentence per tool resolves most platform questions.
Evaluation and profiling answer different questions. When a scenario reports a metric improved, check which kind of metric it was before assuming the change was a win.
A strong overall average can hide a domain you would fail on its own. Track results per domain and keep studying the lowest one, weighting the two largest domains first.
The questions people ask most often when planning their preparation.
Study the ten domains in six weighted phases rather than the order they are published in. Begin with Agent Architecture and Design and Agent Development, since their vocabulary — memory, orchestration, resilience patterns — carries into every other domain. Then move through cognition and knowledge integration, evaluation and operations, deployment and platform tooling, and finish with safety and human oversight.
Most candidates with 1–2 years of applied AI/ML experience need 40 to 60 hours of focused study. Expect the upper end if you have not built a multi-agent system or wired up resilience patterns before, and the lower end if you work with agentic frameworks daily.
Yes, if you already build agentic systems professionally. Three weeks at two to three hours a day covers the ground. Prioritize agent architecture, the Retry and Circuit Breaker patterns, and the RAG pipeline — those three subjects carry the most weight and the most confusable detail.
Agent architecture styles, ReAct, and multi-agent orchestration topologies. It is one of the two largest domains and every later topic — memory, planning, knowledge integration — assumes you already have this vocabulary.
Agent Development catches most candidates out, not because the concepts are exotic but because the Retry and Circuit Breaker patterns are easy to describe and hard to apply correctly to a specific scenario. Candidates who read the definitions once and move on lose marks here.
No, but you do need to know the product landscape precisely. The NeMo Agent Toolkit orchestrates, NIM serves, TensorRT-LLM optimizes, Triton hosts, and NeMo Guardrails constrains. One clear sentence about each is enough to answer the questions that name them.
Not on its own. Practice questions show you where the gaps are but rarely teach the reasoning behind an answer, and this exam favors scenario judgment over recall. Use them after each phase to find your weakest domain, then return to the material for that domain.
Two to three hours a day over four to six weeks suits most people, which fits the 40 to 60 hour range comfortably. Shorter daily sessions with a self-check at the end work better than long weekend blocks for material this dependent on scenario practice.
Agent Architecture and Design and Agent Development first, then Cognition/Planning/Memory and Knowledge Integration together, then Evaluation/Tuning with Run/Monitor/Maintain, then Deployment/Scaling with NVIDIA Platform Implementation, and Safety/Ethics/Compliance with Human-AI Interaction and Oversight last. This follows both weight and the dependencies the source material names on its own.
When you score consistently at or above 70% across all ten domains with none lagging, and you can answer the self-checks in this guide without notes. Since only the overall score matters, one weak domain can be carried by strong results elsewhere — but do not plan to rely on that.
Practise by domain to find which phase you have not really finished, or sit a full-length timed mock at exam pace.