Free NVIDIA-Certified Professional: Agentic AI (NCP-AAI) Practice Questions

Sample NCP-AAI Practice Questions

Browse all 29 free NVIDIA-Certified Professional: Agentic AI practice questions below.

1. Your team is choosing between rolling a custom multi-agent loop and adopting the NVIDIA NeMo Agent Toolkit alongside an existing LangChain-based agent. Select TWO capabilities the NeMo Agent Toolkit provides out-of-the-box that justify adoption.

   • Compilation of your Python agent control flow into native CUDA kernels at startup so multi-step reasoning runs entirely on the GPU.
   • Framework-agnostic instrumentation that runs alongside agents built on LangChain, LlamaIndex, CrewAI, Semantic Kernel, or custom Python, with integrations for Phoenix, Weave, Langfuse, and OpenTelemetry.
   • On-device fine-tuning of the underlying LLM weights using runtime feedback signals collected from agent interactions.
   • Built-in real-time multimodal video reasoning that scores user facial cues and audio sentiment during agent calls.
   • Workflow-level and token-level profiling that tracks latency and token usage across every tool call, retrieval, and LLM invocation in the agent.

2. You’re tasked with selecting the better agent between two candidates based on performance across multiple tasks, including classification, question answering, and summarization. What is the best strategy to compare their performance?

   • Select the model with the fastest average response time across tasks, since latency dominates user-perceived quality in interactive agents.
   • Use task-specific evaluation metrics and compare per-task performance
   • Count the number of tokens each agent consumes across all tasks.
   • Choose the model with the highest accuracy on any single task as a strong general-purpose proxy for overall performance.

3. You operate a NeMo-based agent that performs RAG over a large vector store and then queries an LLM accelerated with TensorRT-LLM behind Triton. Costs are rising and throughput is capped. Which configuration change best improves throughput per dollar while keeping response quality stable?

   • Turn off NeMo Guardrails to remove an extra processing step and save cost, since policy enforcement and content checks add per-token overhead in the response path.
   • Always force the agent to call tools after generation so the LLM "thinks" first.
   • Cache the final generated answers for each user session and return the cache on any query whose embedding is approximately similar, even when the underlying knowledge base has been updated.
   • Batch embedding creation and retrieval calls where possible, and enable response streaming from the LLM to overlap server compute with client consumption.

4. Your RAG-augmented agent retrieves relevant chunks but its final answers still drop facts and occasionally invent citations. You want to improve retrieval quality and answer grounding without retraining the LLM. Select TWO interventions most likely to help.

   • Disable retrieval on borderline queries and let the LLM answer from its parametric knowledge alone, which is more recent than the indexed corpus.
   • Add a re-ranking stage (e.g., a cross-encoder or LLM-based reranker) after the initial vector recall step so the top-k documents passed to the LLM prioritize relevance over surface similarity.
   • Constrain the LLM with citation-aware prompting (e.g., "every claim must cite source X by id") and post-validate that every cited id appears in the retrieval context, rejecting outputs that fabricate sources.
   • Increase the chunk size to the maximum allowed by the retriever so each retrieved chunk contains as much context as possible, even if relevance per token drops.
   • Switch from BGE-style retrieval embeddings to the LLM's own input embedding layer so retrieval and generation use exactly the same vector space.

5. You are developing an agentic AI system that must process enterprise data from multiple client databases (SQL, NoSQL) and transform it into a uniform structure for reasoning. What is the most appropriate design pattern to implement this?

   • Rely on few-shot prompting with a handful of representative rows from each source so the agent infers the schema at runtime.
   • Directly embed raw database queries and their unstructured results into the.
   • Use a single SQL script to copy all data into in-memory tables that the agent can query through a SQL tool whenever needed.
   • Build a modular ETL pipeline to extract, clean, and normalize data from all sources

6. You are designing a pipeline for a conversational agent that answers questions about IT incidents using real-time logs (unstructured) and CMDB (structured) data. What design best supports low-latency reasoning across both sources?

   • Periodically generate plain-text summaries of recent logs and store them in a CSV file that the agent reads on each query.
   • Rely only on CMDB data to avoid inconsistencies in log formats and time.
   • Use regex-based pattern matching on logs and ignore CMDB data, since structured asset metadata is rarely needed for incident triage.
   • Index both logs and CMDB in a unified vector database for hybrid semantic search

7. A product team is enhancing a code-generation agent and wants to incorporate structured user feedback. Which method most effectively ensures that the feedback leads to meaningful, iterative agent improvements?

   • Limiting user inputs to a fixed allowlist of templated questions to reduce parser error rates.
   • Analyzing average token counts in user-agent interactions and using the trend as a proxy for engagement.
   • Gathering unstructured user comments from social media and review forums and treating raw sentiment as the primary signal.
   • Assigning numeric scores to generated outputs using expert reviewers

8. Multiple specialized agents in your distributed system must coordinate asynchronously without tight coupling. Communication patterns must survive agent restarts, scale to bursty traffic, and let agents come online or go offline independently. Select TWO communication patterns that satisfy these constraints.

   • A shared in-memory dictionary held by a single coordinator process that all agents read from and write to via direct method calls.
   • A publish/subscribe topic model where agents subscribe to event types they care about and don't need direct knowledge of which other agents emit those events.
   • A durable message queue or event bus (e.g., RabbitMQ, NATS, Kafka) where producers and consumers are decoupled and messages persist until acknowledged.
   • Synchronous HTTP request/response calls between every pair of agents that share data, with retry-on-failure logic at the application layer.
   • Polling each agent's REST endpoint on a fixed interval to detect new state changes and propagating them through the orchestrator.

9. An organization is deploying an agentic AI system that automates sensitive decision-making tasks. Which of the following is the most appropriate practice to ensure both security and accountability in the system's operations?

   • Store all system logs in local memory for faster access
   • Allow all engineers unrestricted access to logs for faster debugging
   • Anonymize user inputs before storing them in the audit log
   • Implement role-based access control and immutable audit trails

10. Your agent must complete multi-step tasks with external tools (database lookups, API calls, email). The team is debating between a ReAct-style loop (think → act → observe per step) and a Plan-and-Execute pattern (plan all steps upfront, then execute). Select TWO statements that correctly characterize when each pattern is appropriate.

    • ReAct fits well when each step's action depends on the previous step's observation, because the model re-plans on the fly with the latest evidence in context.
    • Plan-and-Execute is the safer default because the upfront plan can be statically verified by a separate LLM before any tool is invoked.
    • ReAct should be avoided in production because it cannot be combined with structured tool-calling APIs offered by modern LLMs.
    • Plan-and-Execute fits well when the task is largely deterministic, parallelizable, and benefits from a single up-front plan that downstream steps can run without re-prompting the LLM.
    • ReAct is strictly faster than Plan-and-Execute because it issues one fused thought-and-action token sequence per step instead of separate planning and execution calls.

11. In the context of agentic AI systems, what is the primary role of the "reasoning module" within an autonomous agent architecture?

    • To define the agent's user-facing chat interface.
    • To interpret sensory data and formulate a plan of action
    • To execute low-level motor commands directly in the environment
    • To schedule compute resources based on hardware availability

12. Which of the following methods is most appropriate for optimizing agent performance in a dynamic multi-agent environment where agents' goals may conflict?

    • Implementing reward shaping with adaptive feedback loops
    • Tuning hyperparameters using a static dataset
    • Minimizing the FLOPs used during agent inference
    • Increasing the number of training epochs without environment changes

13. A retail AI agent is expected to guide users through inventory search, customer policy details, and technical specifications in real-time. The data spans structured APIs, semi-structured HTML product pages, and unstructured user manuals. Which strategy most effectively supports real-time reasoning across these heterogeneous sources?

    • Build a multi-modal knowledge fusion system that combines API calls for structured data with embedding-based document retrieval.
    • Convert all heterogeneous documents to flat CSV files and load them with pandas at runtime so the agent can reason over them in a uniform tabular form.
    • Aggregate all data into a centralized data lake and periodically re-train the agent using prompt-tuning over freshly.
    • Rely exclusively on a single vector database that indexes every document, including structured API payloads, as text embeddings keyed by URL.

14. A developer is designing an agent that must execute a complex multi-step task, such as planning a trip itinerary. To ensure reliable performance, which approach is best suited for structuring prompt chains?

    • Use a single, lengthy prompt containing all instructions and subtasks
    • Implement dynamic prompt chaining with intermediate validations
    • Avoid chaining and instead restart the agent for each new subtask
    • Hardcode all possible outputs in the initial prompt

15. Your RAG agent struggles with queries that contain rare named entities (product SKUs, employee IDs) — vector search returns semantically close but textually wrong documents. Select TWO retrieval-architecture changes that address this failure mode while preserving general semantic recall.

    • Add a lexical retrieval path (BM25 or keyword index) and combine its results with the dense vector retrieval via reciprocal rank fusion or a weighted score blend.
    • Index entity-rich fields (SKU, ID, product name) into a separate keyword/structured index and route entity-bearing queries to that index either in parallel with vector search or as a pre-filter.
    • Increase the dense embedding model's dimensionality (e.g., from 768 to 4096) on the assumption that higher-dimensional vectors better capture rare entities.
    • Replace the embedding model with the LLM's input embedding layer, since the LLM has already memorized rare entities from its training data.
    • Rely on the LLM's parametric memory to recover the missing entity, falling back to retrieval only when the LLM expresses low confidence.

16. Your enterprise corpus has rich relational structure (organizational hierarchy, product BOMs, supplier networks). Pure vector RAG keeps surfacing related-but-tangential documents instead of the right relational hop (e.g., 'who manages the manager of X'). Select TWO architectural patterns that integrate a knowledge graph with RAG for relational queries.

    • Resolve named entities in the user query against the knowledge graph, traverse the relevant relations programmatically, and feed the resulting subgraph (entities + edges) into the LLM as structured context.
    • Run vector retrieval and graph traversal in parallel and fuse their results — vector retrieval surfaces relevant text passages, graph traversal surfaces relational facts, and both are passed to the LLM together.
    • Replace vector retrieval entirely with graph traversal, since knowledge graphs capture all the structure the agent ever needs.
    • Train a custom LLM from scratch on the knowledge graph so the model 'knows' the relations parametrically and no retrieval is needed.
    • Embed the entire knowledge graph as a single text dump and rely on vector retrieval over that dump to answer relational questions.

17. You are deploying a multi-agent AI platform using Docker containers orchestrated by Kubernetes. The system must autoscale based on traffic while ensuring requests are evenly distributed across all agent replicas. Which combination of tools and configurations best satisfies these requirements?

    • Docker Compose deployment using NodePort services for inter-container traffic
    • Kubernetes with ClusterIP services and a Horizontal Pod Autoscaler scaling on CPU
    • Kubernetes with Ingress, HPA, and service type LoadBalancer
    • Docker Swarm with host networking on each node for low-latency intra-cluster traffic

18. A financial services company integrates an agentic AI assistant that processes client data. What should be implemented to ensure compliance guardrails align with both privacy regulations and enterprise policy?

    • Allow the agent to directly query customer databases without approval
    • Implement data anonymization and redaction before model access
    • Disable model audit logs to improve performance
    • Use unmonitored third-party APIs for faster information retrieval

19. You are tasked with building an ETL pipeline that integrates data from a customer relationship management (CRM) platform and a product inventory system into a unified knowledge base for an agentic AI system. Which approach best ensures reliable transformation and alignment of heterogeneous data sources?

    • Load raw extracts from each source first and apply schema-aware transformations directly in the agent's querying layer at runtime.
    • Use direct database exports from each system without any reconciliation transformation, in order to reduce ingestion processing time.
    • Use hardcoded reconciliation rules embedded in the agent's prompt templates to bridge the differences between source schemas at query time.
    • Apply schema mapping and normalization during the transformation phase before loading into the knowledge store

20. An agentic AI system deployed on NVIDIA infrastructure begins exhibiting increasing latency during inference. What is the most proactive step to take under the “Run, Monitor, and Maintain” domain?

    • Review GPU utilization metrics and inspect inference logs for bottlenecks
    • Scale down the number of active inference endpoints to keep cost predictable during the latency incident.
    • Increase the per-request batch size on the inference server without first profiling the model's compute pattern.
    • Upgrade the cluster to newer GPU hardware before investigating root causes in the existing observability data.

21. You're deciding whether to keep agent state (conversation, working memory, in-flight plan) inside the agent process or to externalize it to a database/cache. The system must survive pod restarts, scale horizontally, and allow any replica to handle any user turn. Select TWO design choices that satisfy these requirements.

    • Externalize conversation state and intermediate plan state to a shared store (e.g., Redis, Postgres, or a managed conversation service) keyed by session ID, and treat each agent replica as effectively stateless.
    • Keep all conversation state in process memory of each agent replica and rely on Kubernetes liveness probes to detect failures so the user is rerouted before any state is lost.
    • Use sticky sessions pinning every user to a specific replica forever, so each replica becomes the canonical owner of that user's state without any external store.
    • Use a session-affinity-free load balancer in front of agent replicas, since each replica reads/writes the externalized state and doesn't need sticky routing.
    • Store all agent state inside the LLM's parametric memory by fine-tuning continuously on every conversation, so no external state store is needed.

22. An enterprise team uses the NVIDIA NeMo Agent Toolkit to build a finance assistant capable of retrieving knowledge, invoking tools, and maintaining memory. What optimization approach can reduce response latency while ensuring modular reasoning?

    • Replace tool calls with static prompts for faster execution
    • Use NeMo’s modular agent runtime to parallelize components
    • Remove reasoning modules and rely only on retrieval
    • Disable memory modules to improve speed

23. During the development of an agent designed to interact with humans in a real-world environment, which development practice is most critical to ensure the agent behaves safely and predictably?

    • Enabling unrestricted exploration of all possible actions
    • Implementing guardrails and fail-safes based on environment-specific constraints
    • Training the agent solely in simulated environments without real-world constraints
    • Disabling logging to improve agent response latency

24. Your enterprise knowledge base contains text manuals, embedded images (diagrams, screenshots), and tables. Pure text-only RAG misses the diagrams and parses tables poorly. Select TWO architectural choices that bring images and tables into the retrieval pipeline.

    • Pre-process tables into structured representations (markdown tables, JSON rows, or column-aware chunks) during ingestion rather than treating them as flat OCR'd text, so retrieval can match on column semantics.
    • Train a custom LLM from scratch on every diagram in the corpus so the model 'sees' the diagrams parametrically and no retrieval is needed.
    • Use a multimodal embedding model that maps images and text into a shared vector space (e.g., CLIP-style or NVIDIA's multimodal embedding NIMs), so a text query can retrieve relevant diagrams directly.
    • Skip image and table ingestion entirely; users who need them can search the original documents manually.
    • Convert every image to a one-line text caption, discard the image, and treat the caption as the only retrieval target.

25. An agent-based system designed for customer support is frequently failing to recall key user preferences across separate conversations. As an agentic AI engineer, which architectural improvement would best address this limitation while maintaining efficient memory management?

    • Rely on in-session context windows only, as this approach avoids overfitting on past user data
    • Increase the token limit of the short-term memory buffer during each session
    • Introduce a long-term memory module with vector-based retrieval of relevant user data
    • Store user preferences exclusively in a Redis cache with a short TTL (time-to-live)

26. Your team is debating whether to ship one large LLM-powered agent that handles every capability or to split into specialized sub-agents (router + workers). Select TWO situations where the multi-agent split is clearly the better design choice.

    • The team prefers multi-agent because more agents always means better aggregate quality regardless of how the workload decomposes.
    • Capabilities are owned by different teams or governed by different policies (e.g., a finance specialist needs additional guardrails and audit logging that other paths shouldn't pay for).
    • Different capabilities have very different cost, latency, or accuracy targets — for example, a fast cheap intent classifier in front of an expensive specialist for code generation — so each can be sized and tuned independently.
    • A single user query never needs more than one capability, so splitting allows queries to bypass unrelated agents and reduces overall latency.
    • Multi-agent is required to use NVIDIA NIM, since each NIM endpoint serves only one capability and cannot be reused across agents.

27. A team is deploying an LLM-powered agent that scales based on user demand. Which infrastructure design principle best supports reliability and scalability in this scenario?

    • Load agent prompts into local memory for each request to reduce latency
    • Embed all agent tools and APIs into the same container image to simplify routing
    • Use GPU autoscaling with pre-warmed instances and distributed task queues
    • Allocate fixed compute resources to avoid unpredictable scaling events

28. Which of the following best illustrates a layered safety framework for an agentic AI system operating in a high-stakes environment (e.g., healthcare or finance)?

    • Using model fine-tuning at training time to remove all unsafe behavior across the agent's full input distribution.
    • Relying solely on a downstream content filter to remove inappropriate outputs after generation.
    • Implementing both content filters and escalation to human oversight when risk thresholds are exceeded
    • Disabling output for any uncertain or ambiguous user queries by routing every borderline case to a generic refusal.

29. You are developing a customer service agent for a retail website. The agent must handle product inquiries, process return requests, and escalate complex cases. Which approach best aligns with best practices for practical agent development and integration?

    • Build a modular architecture with task-specific components and API integrations
    • Use a static rule-based engine with hard-coded keyword matching
    • Train a monolithic language model on all historical conversations and deploy as-is
    • Focus entirely on generative answers without any external system integration