NCP-AAINVIDIAAssociate

NVIDIA Certified Professional: Agentic AI NCP-AAI Exam Guide

NCP-AAI is a professional-level, remotely proctored certification for practitioners who architect, develop, deploy, and govern agentic AI systems — multi-agent workflows, tool-using agents, and the memory, retrieval, and oversight machinery around them. It assumes the LLM fundamentals an associate-level exam like NCA-GENL already tests, and instead of asking you to contribute to a system under senior oversight, it expects you to design one yourself and defend the choice. The exam spans ten domains in 120 minutes: agent architecture, agent development and resilience patterns, evaluation and tuning, deployment and scaling, cognition/planning/memory, knowledge integration, NVIDIA platform tooling, live operations, safety and compliance, and human oversight.

Written and reviewed by Alex Mercer, Senior Generative AI Solutions Architect

Exam facts

The mechanics of the exam, and how the five domains divide the marks between them.

Credential
NVIDIA-Certified Professional: Agentic AI
Exam code
NCP-AAI
Level
Professional (intermediate)
Duration
120 minutes
Questions
60–70

Plan for the higher end. At 70 questions in 120 minutes you have a little over 90 seconds each, which is enough to read a scenario twice.

Passing score
70%

NVIDIA does not require a passing grade in every domain individually — only the overall score matters. Weight your prep toward Agent Architecture and Agent Development, which together are almost a third of the paper.

Price
$200 USD
Delivery
Online, remotely proctored, via Certiverse
Validity
2 years from issuance — recertify by retaking
Question format
Multiple choice

Delivered entirely online with no lab or practical component.

Where the marks are

study in this order

  1. Agent Architecture and Design
    15%
  2. Agent Development
    15%
  3. Evaluation and Tuning
    13%
  4. Deployment and Scaling
    13%
  5. Cognition, Planning, and Memory
    10%
  6. Knowledge Integration and Data Handling
    10%
  7. NVIDIA Platform Implementation
    7%
  8. Run, Monitor, and Maintain
    5%
  9. Safety, Ethics, and Compliance
    5%
  10. Human-AI Interaction and Oversight
    5%

Weights translate directly into study hours. Agent Architecture and Design and Agent Development are co-equal at 15% each and tied for the largest domains — together almost a third of the exam, and the conceptual and practical base everything else assumes. Evaluation and Tuning and Deployment and Scaling follow at 13% each. Cognition/Planning/Memory and Knowledge Integration/Data Handling sit at 10% each and underpin each other. NVIDIA Platform Implementation is a mid-sized 7%. The three lightest domains — Run/Monitor/Maintain, Safety/Ethics/Compliance, and Human-AI Interaction and Oversight — are 5% each, and each is cheap to prepare: a focused session on NeMo Guardrails' five rail stages or the EU AI Act's human-oversight requirement covers most of what either domain asks.

Domains

Each domain in weight order: what it covers, what you need to be able to do, where the questions actually concentrate, and the mistake to avoid.

Agent Architecture and Design

15%

of the exam

The foundational structuring of agentic AI systems: how an agent perceives, reasons, acts, remembers, and communicates, and how multiple agents cooperate.

What you need to be able to do

  • Choose between reactive, deliberative, and hybrid agent architectures for a stated scenario
  • Implement the ReAct reasoning-and-acting loop and explain how it differs from chain-of-thought
  • Configure agent-to-agent communication and pick an orchestration topology for a multi-agent team
  • Manage short-term and long-term memory for context retention
  • Integrate a knowledge graph for relational, multi-hop reasoning
  • Design a human-agent interface that supports oversight, not just conversation

Where the questions concentrate

  1. ReAct — the canonical reasoning-and-acting framework, and specifically how the interleaved observation step grounds reasoning and reduces hallucination versus plain chain-of-thought
  2. Multi-agent orchestration topologies — centralized, decentralized, federated, hierarchical — and their distinct coordination and failure profiles
  3. Memory as an architectural decision: the session-scoped context window versus a persistent long-term store
  4. Knowledge graphs versus vector search for relational, multi-hop reasoning
  5. Agent architecture styles — reactive, deliberative, hybrid — and the speed-versus-foresight trade each one makes
  6. Adaptability and scalability of the architecture, and the interface as the surface where human oversight actually happens
Recommended reading · 4
  • ReAct: Synergizing Reasoning and Acting in Language Models— Yao et al., 2022
  • What Are Multi-Agent Systems?— NVIDIA
  • Catch Me If You Can: A Multi-Agent Framework for Financial Fraud Detection
  • Agentic AI: Towards Autonomous Artificial Intelligence Agents
The trap

The most common miss is treating "multi-agent" as inherently centralized — decentralized, federated, and hierarchical are distinct topologies with different failure and governance profiles, and a single agent with many tools is not automatically a multi-agent system. A close second is assuming more reasoning tokens guarantee correctness; in ReAct, it is the observation step that curbs hallucination, not the volume of reasoning.

Agent Development

15%

of the exam

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.

What you need to be able to do

  • Engineer prompts and dynamic, runtime-branching prompt chains
  • Integrate generative and multimodal models across text, vision, and audio
  • Build and connect custom tools, APIs, and functions with clear, idempotent contracts
  • Implement retry logic and graceful failure recovery for transient faults
  • Apply the circuit breaker pattern to stop calling a persistently failing dependency
  • Develop streaming conversation flows with real-time feedback

Where the questions concentrate

  1. The Retry pattern versus the Circuit Breaker pattern — which resilience response fits a transient fault versus a persistent one
  2. The circuit breaker's three states — Closed, Open, Half-Open — and specifically what Half-Open tests for
  3. Idempotency as the precondition that makes a safe retry possible at all
  4. Building and connecting custom tools, APIs, and functions — the NeMo Agent Toolkit's "reusable, composable function calls" model
  5. Multimodal model integration across text, vision, and audio, and routing a task to the right model
  6. Dynamic prompt chains, streaming conversation flows, and real-time feedback mechanisms
Recommended reading · 4
  • Retry Pattern— Azure Architecture Center, Microsoft Learn
  • Circuit Breaker Pattern— Azure Architecture Center, Microsoft Learn
  • Transient Fault Handling— Azure Architecture Center, Microsoft Learn
  • Building Multimodal AI RAG With LlamaIndex, NVIDIA NIM, and Milvus
The trap

The phrase "error handling" and "write software components or scripts" makes this sound like a coding exam. It is not — almost nothing here tests Python syntax. The single biggest trap is naming only Closed and Open for the circuit breaker and forgetting Half-Open, its recovery test; a close second is retrying a non-idempotent operation without a safeguard, or nesting retry layers that multiply load on an already-struggling dependency.

Evaluation and Tuning

13%

of the exam

Proving an agent works and then making it better: evaluation pipelines and benchmarks, structured feedback, and tuning against the accuracy-versus-latency trade-off.

What you need to be able to do

  • Implement evaluation pipelines and task benchmarks to measure agent performance
  • Compare agent performance across tasks and datasets
  • Distinguish profiling (where time and tokens go) from evaluation (how good the output is)
  • Tune model parameters for accuracy versus latency and cost trade-offs
  • Collect structured user feedback and feed it into iterative refinement
  • Analyze evaluation results to guide a targeted, one-variable-at-a-time optimization

Where the questions concentrate

  1. Profiling versus evaluation — the most testable single distinction in the domain
  2. The accuracy-versus-latency trade-off, and why "just maximize accuracy" is usually the wrong answer for a production scenario
  3. The NeMo Agent Toolkit's built-in evaluation system and profiler — token counts, timings, and bottlenecks
  4. Observability integrations — Phoenix, Weave, Langfuse, OpenTelemetry — for step-level tracing
  5. Structured feedback and the data flywheel: feedback informs refinement but does not replace repeatable benchmarks
  6. Targeted optimization: change one high-impact variable and re-evaluate on a fixed set
Recommended reading · 4
  • NVIDIA Agent Intelligence Toolkit Overview
  • NVIDIA Agent Intelligence Toolkit FAQ
  • Powering the Next Generation of AI Agents
  • Navigating the Challenges: 5 Common Pitfalls in Agentic AI Adoption
The trap

Evaluation and profiling get treated as the same activity, and they are not: evaluation tells you whether to change something, profiling tells you where the cost is. A question that optimizes a profiler metric like latency without re-checking evaluation is testing whether you will silently let quality degrade while a dashboard number improves.

Deployment and Scaling

13%

of the exam

Taking an agent from a laptop to production: containerized multi-agent deployment, MLOps governance, profiling under load, and balancing cost against availability.

What you need to be able to do

  • Deploy and orchestrate multi-agent systems at production scale
  • Apply MLOps practices for CI/CD, monitoring, and governance
  • Profile performance and reliability under distributed system load
  • Scale deployments with containerization and load balancing
  • Optimize deployment cost while preserving high availability

Where the questions concentrate

  1. NVIDIA NIM — precisely what it is (a containerized, GPU-accelerated inference microservice) and precisely what it is not (a model)
  2. Containerization and Kubernetes with load balancing as the scaling mechanism — not "one bigger VM"
  3. The serving stack's division of labor: NIM packages the model, TensorRT-LLM optimizes it, Triton serves it, Kubernetes scales the containers
  4. Profiling under distributed load before committing to a scaling plan, since contention and tail effects only appear at scale
  5. Balancing deployment cost against high availability by right-sizing for peak demand and failover
  6. MLOps as CI/CD, monitoring, and governance from the start, not a post-launch addition
Recommended reading · 4
  • Scaling LLMs With NVIDIA Triton and TensorRT-LLM Using Kubernetes
  • Measure and Improve AI Workload Performance With NVIDIA DGX Cloud Benchmarking
  • Kubernetes Glossary— NVIDIA
  • vLLM— GitHub
The trap

NIM is not a model, and NIM is not Triton — it is a prepackaged microservice, and Triton is the general inference server underneath it (or something you run yourself). A close second: assuming single-node benchmarks predict distributed behavior, when contention, network latency, and tail effects only show up once you actually scale.

Cognition, Planning, and Memory

10%

of the exam

How an agent thinks: the memory taxonomy, reasoning frameworks, planning strategies for multi-step decisions, and adapting from experience.

What you need to be able to do

  • Implement short-term and long-term memory mechanisms for context retention
  • Apply reasoning frameworks such as chain-of-thought and task decomposition
  • Engineer planning strategies for sequential, multi-step decisions
  • Manage stateful orchestration to coordinate complex, multi-turn tasks
  • Adapt reasoning strategies based on prior experience and feedback

Where the questions concentrate

  1. The full memory taxonomy — short-term, long-term, episodic, semantic, procedural — and not conflating the last three
  2. The five planning directions (Task Decomposition, Plan Selection, External Module, Reflection, Memory), not just decomposition
  3. Why an LLM needs an explicit memory component at all, since every call is stateless on its own
  4. Stateful orchestration as the point where memory and planning meet
  5. Chain-of-thought and task decomposition as reasoning frameworks, and their connection to ReAct
  6. Adapting an agent's reasoning from logged experience and structured feedback
Recommended reading · 3
  • Understanding the Planning of LLM Agents: A Survey— Huang et al., 2024, arXiv:2402.02716
  • AI Agent Memory— IBM
  • Large Language Models Are in Context Learners— arXiv:2310.10501
The trap

Reciting only task decomposition as "the" planning method is the standing trap — the underlying survey names five distinct directions, and Reflection and Plan Selection are common distractor-versus-correct pairs. A second, equally common miss is treating short-term memory as if it persists across sessions; it does not, by definition.

Knowledge Integration and Data Handling

10%

of the exam

Feeding an agent trusted external knowledge: the canonical RAG pipeline, vector databases, ETL and data quality, and reasoning over mixed structured and unstructured sources.

What you need to be able to do

  • Implement retrieval pipelines — RAG, embedded search, and hybrid approaches
  • Configure and optimize a vector database for fast retrieval
  • Build ETL pipelines to integrate enterprise or client data sources
  • Conduct data-quality checks, augmentation, and preprocessing
  • Enable real-time reasoning over structured and unstructured knowledge

Where the questions concentrate

  1. The canonical RAG pipeline end to end — ingest and chunk, embed, store, retrieve, augment, generate
  2. Distinguishing vector RAG, GraphRAG, HybridRAG, and agentic RAG from one another
  3. Why query and document embeddings must come from the same model and vector space to be comparable
  4. Data quality and ETL as the cap on retrieval accuracy, not optional plumbing underneath a RAG agent
  5. Agentic RAG's reason-and-retry behavior versus a single-shot retrieval lookup
  6. Real-time reasoning across structured (databases, graphs, tables) and unstructured (documents, chat, images) sources
Recommended reading · 2
  • How to Make Your LLM More Accurate with RAG and Fine-Tuning— Towards Data Science
  • NVIDIA Enterprise RAG Blueprint— NVIDIA
The trap

GraphRAG and vector RAG get set up as an either/or choice, and they are not — HybridRAG exists specifically to combine relational and semantic retrieval. The second common miss is treating agentic RAG as just RAG with an agent label on it: it plans sub-questions and reformulates on thin results rather than doing one lookup and stopping.

NVIDIA Platform Implementation

7%

of the exam

The NVIDIA-specific domain: using the NeMo Agent Toolkit, NIM, NeMo Guardrails, TensorRT-LLM, and Triton together to build and accelerate agentic systems.

What you need to be able to do

  • Integrate NeMo Guardrails for compliance and safety enforcement
  • Deploy NIM microservices for high-performance inference
  • Optimize agent workflows with the NeMo Agent Toolkit
  • Leverage TensorRT-LLM and Triton Inference Server for latency reduction
  • Manage and optimize multimodal input pipelines on NVIDIA hardware

Where the questions concentrate

  1. The NeMo Agent Toolkit's framework-agnostic design — working alongside LangChain, LlamaIndex, CrewAI, and Semantic Kernel — plus its built-in agent types and bidirectional Model Context Protocol support
  2. NIM as a containerized, GPU-accelerated inference microservice, and its supported backends (TensorRT-LLM, vLLM)
  3. TensorRT-LLM (optimizes) versus Triton (serves) as two roles the exam constantly tests against each other
  4. NeMo Guardrails sitting between application code and the LLM as a first-class platform component
  5. Multimodal input pipeline routing — text, image, audio, video — on NVIDIA hardware
  6. How the toolkit, NIM, TensorRT-LLM, Triton, and Guardrails compose into one agentic stack
Recommended reading · 4
  • NVIDIA Agent Intelligence Toolkit Overview— NVIDIA Agent Intelligence Toolkit (1.1.0)
  • NVIDIA NeMo Guardrails— GitHub
  • Mastering LLM Techniques: Inference Optimization— NVIDIA
  • Best Practices— NVIDIA TensorRT Documentation
The trap

The toolkit does not replace your framework — it is framework-agnostic and works alongside LangChain, CrewAI, LlamaIndex, and Semantic Kernel, and its Model Context Protocol support is bidirectional, client and server both. Conflating the toolkit, NIM, TensorRT-LLM, Triton, and Guardrails is the domain's most common miss: each of the five has exactly one job.

Run, Monitor, and Maintain

5%

of the exam

Keeping a deployed agent healthy: monitoring dashboards, logs and per-step tracing for root-cause diagnosis, continuous benchmarking, and automated tuning and versioning.

What you need to be able to do

  • Define monitoring dashboards and reliability metrics for a live agent
  • Track logs, errors, and anomalies for root-cause diagnosis
  • Continuously benchmark a deployed agent against prior versions
  • Implement automated tuning, retraining, and versioning in production
  • Ensure continuous uptime, transparency, and trust in live deployments

Where the questions concentrate

  1. Per-step telemetry and tracing as what actually diagnoses multi-agent behavior drift — infrastructure metrics alone miss it
  2. Monitoring (live operational health) versus evaluation (pre-release quality) as two distinct activities
  3. Continuous regression benchmarking of a live agent against prior versions
  4. Automated tuning, retraining, and versioning — the objective explicitly calls for automation, not manual one-offs
  5. Reliability metrics: latency percentiles, throughput, error rate, resource utilization, and uptime
  6. Versioning as traceability and clean rollback, not just file naming
Recommended reading · 3
  • What Is AI Agent Evaluation?
  • A Guide to Monitoring Machine Learning Models in Production
  • Monitoring Machine Learning Models in Production: How to Track Data Quality and Integrity
The trap

Monitoring only infrastructure metrics — CPU, GPU, and memory graphs — misses agent-behavior drift entirely; you need step-level tracing to catch a multi-agent system producing conflicting actions. Treating retraining and versioning as manual, one-off tasks is the second standing miss, since the objective names automation explicitly.

Safety, Ethics, and Compliance

5%

of the exam

Making an agent responsible: system security and audit trails, compliance guardrails, bias and toxicity mitigation, layered safety, and licensing and regulatory compliance.

What you need to be able to do

  • Design and enforce system security and audit trails
  • Integrate compliance guardrails for privacy and enterprise policy
  • Mitigate bias and toxicity in agent outputs
  • Deploy layered safety frameworks combining filters and escalation protocols
  • Ensure licensing and regulatory compliance

Where the questions concentrate

  1. NeMo Guardrails' five rail stages — input, dialog, retrieval, execution, output — not just input and output
  2. Colang plus YAML as the configuration approach for guardrail flows, extendable with custom Python actions
  3. Layered safety: combining multiple detection methods (content safety, jailbreak protection, topic control) plus human escalation, never one filter alone
  4. Isolating authentication and authorization away from the LLM, and validating tool calls with execution rails
  5. Bias and toxicity mitigation as a data and training-level concern, distinct from what a guardrail can do
  6. The EU AI Act, Article 14's requirement for effective human oversight of high-risk systems
Recommended reading · 4
  • NeMo Guardrails— NVIDIA Developer
  • NVIDIA NeMo Guardrails— GitHub
  • Proposal for a Regulation Laying Down Harmonised Rules on Artificial Intelligence— EU AI Act
  • Building Safer LLM Apps With LangChain Templates and NVIDIA NeMo Guardrails
The trap

Naming only input and output rails is the domain's most common miss — NeMo Guardrails has five stages, also dialog, retrieval, and execution. The second is conflating guardrails with bias mitigation: guardrails constrain and steer behavior at runtime, they do not retrain or debias the underlying model.

Human-AI Interaction and Oversight

5%

of the exam

Keeping humans in control: intuitive user-in-the-loop interfaces, structured feedback loops, transparency mechanisms, and human oversight and intervention points.

What you need to be able to do

  • Build intuitive UIs with user-in-the-loop interaction
  • Design structured feedback loops that guide iterative agent improvement
  • Implement transparency mechanisms — explainable reasoning and decision traceability
  • Enable human oversight and intervention for accountability and trust

Where the questions concentrate

  1. Human-in-the-loop benefits (accuracy, accountability, transparency) and drawbacks (cost and latency, reviewer inconsistency, privacy risk)
  2. HITL techniques — supervised learning (labeling), RLHF (a reward model trained from feedback), and active learning (only low-confidence cases)
  3. The EU AI Act, Article 14's human-oversight requirement for high-risk systems
  4. Transparency and decision traceability as named, tested objectives, not cosmetic polish
  5. Structured feedback loops as a learning signal, not just an approval gate
  6. The UI as the concrete surface where oversight, feedback, and intervention actually happen
Recommended reading · 3
  • Human-in-the-Loop AI— HolisticAI
  • Human-in-the-Loop Agentic AI Systems— OneReach.ai
  • NVIDIA Data Flywheel Glossary— NVIDIA
The trap

HITL gets treated as a free accuracy upgrade, and the drawbacks are just as testable as the benefits — added cost and latency is real, human reviewers disagree with each other, and exposing data to reviewers carries its own privacy risk. The second common miss is confusing RLHF, which trains a reward model from human feedback, with plain supervised labeling.

Who the exam is for, and how deep to go

The role this certification is written for, and the level of detail the questions expect.

An intermediate agentic AI practitioner who designs, evaluates, and deploys autonomous AI systems — constructing resilient, secure, and trustworthy agents such as customer or employee assistants, meeting companions, and productivity tools, then keeping them healthy once they are live.

What the role involves

  • End-to-end agent development, from prototype through production
  • Model and framework selection and integration across text, vision, and audio
  • Agent structure and tool creation — building the capabilities an agent acts through
  • Orchestration of single- and multi-agent workflows
  • Assessment, evaluation, and iterative improvement of a deployed agent

Recommended background

  • 2–3 years in AI and machine learning roles, with hands-on production-level agentic AI projects (chatbots, workflow automation)
  • Memory management for short- and long-term context
  • Deployment of containerized workflows, with monitoring and logging around them
  • Ethical safeguards — bias detection, privacy preservation, guardrails
  • MLOps workflow deployment and GPU-optimized operations

How deep the questions go

Every domain in the source material carries the same scope note in different words: you are expected to reason about why an architecture, memory layout, resilience pattern, or orchestration topology fits a given scenario, not merely recite a definition. Objectives are written as "implement", "configure", and "orchestrate" rather than "describe" or "list". Expect a scenario, a constraint, and a choice between plausible options — the professional skill being tested is picking correctly under that constraint, not defining the vocabulary.

Booking, cost and retaking NCP-AAI

How to register, what it costs, what happens if you fail, and what you may take into the room.

How do you book the NCP-AAI exam?

You register through NVIDIA's certification portal and check out via Certiverse, NVIDIA's testing partner — you'll need a Certiverse account to access the exam. It is delivered online under remote proctoring, so there is no test centre to travel to: you need a webcam, a stable connection, a government photo ID, and a quiet room you can clear of notes and second screens.

What does NCP-AAI cost?

The exam fee is $200 USD. NVIDIA periodically offers discounted or complimentary vouchers around GTC and other developer events, so it is worth checking for an active promotion before paying full price. The fee covers one attempt; a retake is charged again.

What happens if you fail, and how soon can you retake it?

A failed attempt is not published anywhere and does not appear on your record. You may retake the exam, paying the fee again, subject to NVIDIA's standard waiting period between attempts.

When do you get your result?

You see a pass or fail outcome as soon as you submit. The digital badge and optional certificate follow by email, indicating your certification level and topic, and the badge is verifiable by anyone you share it with.

What can you bring into the exam?

Nothing. No notes, no calculator, no second monitor, no reference material of any kind, and the proctor will ask you to show the room before you start.

Is there a lab or practical component?

No. NCP-AAI is entirely multiple choice — 60 to 70 questions in 120 minutes, delivered online through Certiverse. You will not be asked to write or deploy code during the exam itself.

NCP-AAI or another NVIDIA certification?

Four NVIDIA generative-AI credentials have similar names and very different scopes. How this one differs from its neighbours, and who should sit each.

NCP-AAI vs NCA-GENL

NVIDIA Certified Associate: Generative AI LLMs

How it differs

The associate-level entry point into the same underlying technology: 60 minutes against 90, five domains against ten, and no published cut score where NCP-AAI has a 70%. It expects you to contribute to an LLM system under senior oversight rather than architect an agent independently.

Choose it when

You have not built with LLMs before, or want the foundations — transformers, retrieval, evaluation — that NCP-AAI assumes and does not re-teach. Most people sit NCA-GENL first.

NCP-AAI vs NCA-GENM

NVIDIA Certified Associate: Generative AI Multimodal

How it differs

Also associate-level and also 60 minutes, but spread across seven domains covering images, audio, and video alongside text, with no published cut score where NCP-AAI has a 70%. It shares NCP-AAI's interest in multimodal integration but at associate depth and without the agent-architecture or orchestration content.

Choose it when

Your work is multimodal generation and analysis rather than agents specifically. If you are building tool-using or multi-agent systems, NCP-AAI is the closer match.

NCP-AAI vs NCP-GENL

NVIDIA Certified Professional: Generative AI LLMs

How it differs

The professional-level LLM exam without the agent layer: 120 minutes, ten domains, and a published 70% cut score, covering architecture, prompt engineering, fine-tuning, optimization, and deployment for LLM systems generally rather than agentic ones specifically.

Choose it when

You want the professional credential for LLM systems in general — serving, fine-tuning, optimization — without the agent-architecture, multi-agent orchestration, and agentic-RAG content that is specific to NCP-AAI.

NCP-AAI glossary

The vocabulary the exam assumes you already have, defined the way the questions use it.

ReActReasoning and Acting15%
An agent control loop that interleaves reasoning traces with tool-calling actions: a Thought plans the next move, an Action calls a tool, and an Observation feeds the result back in. The observation step is what grounds reasoning in real output and reduces hallucination compared to reasoning alone.
Multi-agent orchestration topology15%
The control structure a team of agents uses to coordinate: centralized (one supervisor), decentralized (autonomous peers, no controller), federated (cross-organization protocols), or hierarchical (tiered supervision). Each has a different failure and governance profile.
Circuit breaker15%
A state machine — Closed, Open, Half-Open — that stops an application from repeatedly calling an operation likely to keep failing. An Open breaker fails fast on purpose; Half-Open sends limited trial requests to test recovery before fully reopening traffic.
Retry pattern15%
Transparently reattempting an operation that failed due to a transient fault, using cancel, immediate retry, or retry-after-delay depending on the fault type. Only safe on an idempotent operation, and never nested inside another retry layer.
Idempotent operation15%
An operation that produces the same result no matter how many times it runs — the precondition that makes a retry safe, since retrying a non-idempotent operation (like a payment) can double-apply its side effects.
NeMo Agent Toolkit7%
A framework-agnostic library (formerly AgentIQ; the package is `nvidia-nat`) that connects existing agents to data sources and tools across any framework — LangChain, LlamaIndex, CrewAI, Semantic Kernel — without replatforming. Ships built-in agent types, a profiler, observability integrations, and bidirectional Model Context Protocol support.
NIMNVIDIA Inference Microservices13%
Portable, performance-optimized, containerized inference microservices that expose a model behind an industry-standard API endpoint, supporting backends like TensorRT-LLM and vLLM. NIM is not a model — it is the microservice that serves one.
TensorRT-LLM13%
An LLM inference optimizer that compiles a model for fast GPU inference through kernel fusion, precision calibration, and KV-cache handling. It optimizes; something else — typically Triton or NIM — serves the result.
Triton Inference Server13%
A general-purpose model server that runs models across frameworks with dynamic batching and concurrency. Triton serves what it is given; it does not optimize the model itself.
NeMo Guardrails5%
An open-source programmable safety layer that sits between application code and the LLM, blocking, altering, or validating unsafe or policy-violating input and output across five rail stages — input, dialog, retrieval, execution, output — configured in Colang and YAML.
Knowledge graph15%
A structure encoding entities and the relationships between them, enabling multi-hop, relational reasoning that flat, similarity-based vector search misses. Graphs and vector search are complementary, not interchangeable.
GraphRAG / HybridRAG10%
GraphRAG retrieves over a knowledge graph for relational, multi-hop, verifiable reasoning; HybridRAG combines graph-based and vector-based retrieval to balance relational and semantic strengths. They are not either/or.
Agentic RAG10%
A retrieval pattern where an agent plans focused sub-questions, retrieves per sub-question, reformulates and retries when results are thin, then synthesizes an answer — reasoning over retrieval rather than doing one single-shot lookup.
Agent memory taxonomy10%
The finer-grained memory categories beyond short-term/long-term: episodic (specific past events), semantic (generalized facts), and procedural (learned skills, often refined with reinforcement learning). Conflating the three is a standing exam trap.
Five planning directions10%
The LLM-agent planning taxonomy: Task Decomposition, Plan Selection, External Module, Reflection, and Memory. Reciting only task decomposition as "the" planning method misses the other four, which the exam tests directly.
Model Context Protocol (MCP)Model Context Protocol7%
A protocol for connecting an agent to external tools and data sources. The NeMo Agent Toolkit supports it bidirectionally — it can act as an MCP client and an MCP server, not just one or the other.
Human-in-the-loop (HITL)Human-in-the-loop5%
A design pattern where a human actively reviews, approves, or overrides an automated system's outputs. It improves accuracy and accountability, but is not free: added cost and latency, reviewer inconsistency, and privacy exposure are real, tested drawbacks.

Essential reading

The papers and documentation worth your time before the exam, most valuable first. The top four cover the intellectual backbone of the whole syllabus.

  1. ReAct: Synergizing Reasoning and Acting in Language ModelsYao et al., 2022 — the reasoning-and-acting framework the whole exam assumes
  2. Understanding the Planning of LLM Agents: A SurveyHuang et al., 2024, arXiv:2402.02716 — the five planning directions
  3. AI Agent MemoryIBM — the memory taxonomy behind Domain 5
  4. Retry PatternAzure Architecture Center, Microsoft Learn
  5. Circuit Breaker PatternAzure Architecture Center, Microsoft Learn
  6. NVIDIA Agent Intelligence Toolkit OverviewNVIDIA — the toolkit tested across Domains 2, 3, and 7
  7. NeMo GuardrailsNVIDIA Developer
  8. Scaling LLMs With NVIDIA Triton and TensorRT-LLM Using KubernetesNVIDIA
  9. Building Multimodal AI RAG With LlamaIndex, NVIDIA NIM, and MilvusNVIDIA
  10. What Are Multi-Agent Systems?NVIDIA
  11. Proposal for a Regulation Laying Down Harmonised Rules on Artificial IntelligenceEU AI Act, Article 14
  12. Mastering LLM Techniques: Inference OptimizationNVIDIA

Common questions

The questions people ask most often before booking this exam.

What is the passing score for NCP-AAI?

70%. NVIDIA does not require a passing grade in every domain individually, only overall, but the safest preparation still scores well across all ten domains — especially the two largest, Agent Architecture and Design and Agent Development.

How many questions are on the exam?

Around 60 to 70 multiple-choice questions in 120 minutes. That is a little over 90 seconds each at the longer end of the paper, so the pacing is comfortable if you do not stall.

How hard is NCP-AAI?

It is a professional-level exam, and the difficulty is depth as much as breadth. Where an associate exam asks you to recognize a concept, NCP-AAI asks you to pick correctly between two plausible resilience patterns, orchestration topologies, or planning strategies for a stated scenario.

How long does it take to prepare?

With 1–2 years of applied AI/ML experience and a production-level agentic project behind you, 40 to 60 hours of focused study is realistic. Budget more if you have not built a multi-agent system or wired up resilience patterns before.

Which domain should I study first?

Agent Architecture and Design. It is tied for the largest domain and its concepts — memory, orchestration topology, ReAct — are assumed by Agent Development, Cognition/Planning/Memory, and Knowledge Integration alike.

Do I need hands-on experience with NVIDIA-specific agent tooling?

Yes, at the level of knowing what each tool is for. The NeMo Agent Toolkit, NIM, TensorRT-LLM, Triton, and NeMo Guardrails all appear, and questions test whether you can place each one's job correctly in a stack, not whether you have deployed all five yourself.

Does the exam treat multi-agent systems as their own topic?

Multi-agent orchestration is folded into Agent Architecture and Design as the topology question — centralized, decentralized, federated, hierarchical — while agent-to-agent development, tools, and resilience live in Agent Development.

How much does it cost and how is it delivered?

NCP-AAI costs $200 USD and is delivered online under remote proctoring through Certiverse, NVIDIA's exam platform. There is no lab or practical component — it is entirely multiple choice.

How long is the certification valid?

Two years from issuance. Recertification means retaking the exam.

Is NCP-AAI a good first agentic-AI certification?

Not usually. It assumes the LLM fundamentals an associate exam like NCA-GENL already tests and takes them as given, so it is a poor entry point if you have not built with LLMs before.

You know the shape of the exam. Now sequence the work.

The study guide turns everything above into six ordered phases, each with a practice exercise and self-checks to tell you when to move on.

Open the study guidePractise by domain