NCP-AAI1 pageprintable

NVIDIA Certified Professional: Agentic AI NCP-AAI Cheatsheet

Everything worth re-reading in the hour before you sit NCP-AAI, on one page. No explanations — just the facts, the weights, the traps and the judgement calls. Print it or keep it open beside your last practice run.

Exam facts

Credential
NVIDIA-Certified Professional: Agentic AI
Exam code
NCP-AAI
Level
Professional (intermediate)
Duration
120 minutes
Questions
60–70
Passing score
70%
Price
$200 USD
Delivery
Online, remotely proctored, via Certiverse
Validity
2 years from issuance — recertify by retaking
Question format
Multiple choice

Domain weights

  1. Agent Architecture and Design15%
  2. Agent Development15%
  3. Evaluation and Tuning13%
  4. Deployment and Scaling13%
  5. Cognition, Planning, and Memory10%
  6. Knowledge Integration and Data Handling10%
  7. NVIDIA Platform Implementation7%
  8. Run, Monitor, and Maintain5%
  9. Safety, Ethics, and Compliance5%
  10. Human-AI Interaction and Oversight5%

Study time follows weight. The top two domains are more than half the exam.

Exam-day tactics

  1. Pace at just over a minute a question. 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.
  2. Find the constraint before you eliminate. 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.
  3. Know each pattern's trigger condition, not just its name. 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.
  4. Know each NVIDIA tool by its one job. Toolkit orchestrates, NIM serves, TensorRT-LLM optimizes, Triton hosts, Guardrails constrains, a vector database indexes. One clear sentence per tool resolves most platform questions.
  5. Separate "is it good" from "is it fast". 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.
  6. Measure readiness by your weakest domain. 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.

One trap per domain

  • Agent Architecture and Design15%

    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 Development15%

    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 Tuning13%

    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 Scaling13%

    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 Memory10%

    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 Handling10%

    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 Implementation7%

    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 Maintain5%

    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 Compliance5%

    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 Oversight5%

    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.

Where the questions concentrate

The three subjects that carry the most marks in each domain.

Agent Architecture and Design15%

  1. ReAct
  2. Multi-agent orchestration topologies
  3. Memory as an architectural decision

Agent Development15%

  1. The Retry pattern versus the Circuit Breaker pattern
  2. The circuit breaker's three states
  3. Idempotency as the precondition that makes a safe retry possible at all

Evaluation and Tuning13%

  1. Profiling versus evaluation
  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

Deployment and Scaling13%

  1. NVIDIA NIM
  2. Containerization and Kubernetes with load balancing as the scaling mechanism
  3. The serving stack's division of labor

Cognition, Planning, and Memory10%

  1. The full memory taxonomy
  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

Knowledge Integration and Data Handling10%

  1. The canonical RAG pipeline end to end
  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

NVIDIA Platform Implementation7%

  1. The NeMo Agent Toolkit's framework-agnostic design
  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

Run, Monitor, and Maintain5%

  1. Per-step telemetry and tracing as what actually diagnoses multi-agent behavior drift
  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

Safety, Ethics, and Compliance5%

  1. NeMo Guardrails' five rail stages
  2. Colang plus YAML as the configuration approach for guardrail flows, extendable with custom Python actions
  3. Layered safety

Human-AI Interaction and Oversight5%

  1. Human-in-the-loop benefits (accuracy, accountability, transparency) and drawbacks (cost and latency, reviewer inconsistency, privacy risk)
  2. HITL techniques
  3. The EU AI Act, Article 14's human-oversight requirement for high-risk systems

Every NVIDIA tool by its one job

Most wrong options are a real product doing a job that belongs to a different one.

ToolIts jobNot for
NeMo Agent ToolkitOrchestrates and evaluates an agent workflow, framework-agnosticallyServing or optimizing a model — that is NIM, TensorRT-LLM, and Triton's job.
NVIDIA NIMServes a model behind a standard API endpoint as a containerized microserviceBeing the model itself, or replacing Triton underneath it.
TensorRT-LLMOptimizes an LLM for fast GPU inference before servingServing traffic on its own — something else hosts the optimized engine.
Triton Inference ServerServes models across frameworks with dynamic batching and concurrencyOptimizing the model itself — Triton runs what you give it.
NeMo GuardrailsConstrains agent input, output, and tool calls at runtime, with an auditable logDebiasing or retraining the underlying model — that is a data and training concern.
Vector database (e.g., Milvus)Indexes embeddings and answers nearest-neighbor queries for RAGGenerating the embeddings — an embedding model produces them.
KubernetesOrchestrates container replicas: scheduling, self-healing, autoscalingOptimizing or serving a model directly — it schedules the containers that do.

Metrics, and what each one hides

The exam asks which metric answers which question. The blind spot is the half most candidates cannot state.

MetricMeasuresUse whenBlind spot
Latency percentiles (p50/p95/p99)How long a request takes, including tail behaviorJudging whether a deployment meets a stated response-time requirementA good median can hide a bad p99 that the most-affected users actually experience
ThroughputRequests or tokens processed per secondSizing capacity for a stated loadHigh throughput at high latency can still fail a user-facing requirement
Error rateShare of requests or tool calls that failTracking live reliability and deciding when a circuit breaker should tripSays nothing about whether the successful responses were actually correct
Profiler output (token counts, timings, bottlenecks)Where an agent run spends time and tokensDeciding what to optimize before changing anythingTells you where the cost is, not whether the output is any good — that is evaluation's job
Task benchmark score (evaluation pipeline)How good the agent's outputs are against a fixed, repeatable task setComparing agent versions or configurations after a changeA benchmark score alone does not tell you which stage — reasoning, retrieval, or a tool call — produced a bad run
Uptime / availabilityShare of time the live service is reachable and functioningJudging whether a deployment meets a stated high-availability requirementA system can be up and still be behaviorally wrong — uptime does not catch quality drift

Numbers worth knowing

120 min
Exam duration.
60–70
Questions on the paper, multiple choice.
10 domains
Agent Architecture and Design through Human-AI Interaction and Oversight.
15%
Agent Architecture and Design, and Agent Development — tied for the largest domains.
5 rail stages
NeMo Guardrails: input, dialog, retrieval, execution, output.
5 planning directions
Task Decomposition, Plan Selection, External Module, Reflection, Memory.
3 breaker states
Circuit breaker: Closed, Open, Half-Open.
$200
Exam fee in USD, one attempt.
2 years
Validity. Recertify by retaking.

Acronyms

The fastest-decaying knowledge under exam pressure.

RAG
Retrieval-Augmented Generation
MCP
Model Context Protocol
NIM
NVIDIA Inference Microservices
HITL
Human-in-the-Loop
RLHF
Reinforcement Learning from Human Feedback
ETL
Extract, Transform, Load
ANN
Approximate Nearest Neighbor
MLOps
Machine Learning Operations
CI/CD
Continuous Integration / Continuous Delivery
PII
Personally Identifiable Information

If you only read four things

  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

Ready for a timed run?

Sit a full-length mock at exam pace, or drill the domain you are weakest in.

Take a mock testPractise by domain