Question bank
NVIDIA Certified Professional - Agentic AI
44 NVIDIA Certified Professional - Agentic AI questions with the correct answer and a written explanation, organised across 10 exam domains.
- 44 questions
- 10 domains
- Foundation level
certilumQuestion index
Jump straight to any question. Answers and explanations are inline.
Agent Architecture and Design
6 questions in this domain
- Question 1Single Choice
What technique involves prompting a model to generate intermediate reasoning steps to solve complex problems?
- ASimple Instruction
- BChain-of-Thought (CoT)Correct answer
- CFew-Shot Prompting
- DTask Decomposition
Why this is the answer
Chain-of-Thought (CoT) prompting encourages the model to generate intermediate reasoning steps, facilitating complex problem solving.
- Question 2Multiple Select
In the ReAct framework, which three components form the iterative reasoning and acting loop?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DUser Input
Why this is the answer
The ReAct framework combines reasoning traces (thought), task-specific actions (action), and results (observation).
- Question 3Interactive
Look at the few-shot example below. Is the reasoning pattern correctly implemented for agentic generalization?
- AYes, it includes reasoning stepsCorrect answer
- BNo, it only provides input/output
- CNo, it lacks observation
- DYes, it uses simple instructions
Why this is the answer
Correct few-shot reasoning for agents requires (Input/Thought/Action/Output) rather than just (Input/Output).
- Question 4Single Choice
What is the primary purpose of Task Decomposition in agent architecture?
- ATo increase context window size
- BTo prevent the agent from being overwhelmedCorrect answer
- CTo automate tool execution directly
- DTo reduce the number of reasoning steps
Why this is the answer
Task decomposition breaks high-level goals into executable sub-problems to prevent the agent from becoming overwhelmed.
- Question 5Multiple Select
Which of these are considered 'Closed-Loop' reasoning techniques for agents?
- ASelf-ReflectionCorrect answer
- BSelf-CorrectionCorrect answer
- CSimple Instruction
- DFIFO Token Management
Why this is the answer
Self-reflection and self-correction allow agents to review previous outputs for inconsistencies, creating a closed-loop system.
- Question 6Interactive
Analyze the loop below. Is the 'observation' variable correctly identifying the tool's role?
- AIt is a user input
- BIt is the tool outputCorrect answer
- CIt is a reasoning step
- DIt is a prompt instruction
Why this is the answer
In ReAct, the observation is the output of the tool being fed back into the model, not user input.
Agent Development
6 questions in this domain
- Question 7Single Choice
What is the primary purpose of Chain-of-Thought (CoT) prompting in Large Language Models?
- AIncrease context window size
- BImprove reasoning via intermediate stepsCorrect answer
- CSpeed up raw token generation
- DReduce the need for tool calls
Why this is the answer
CoT improves reasoning by prompting the model to generate a sequence of intermediate reasoning steps.
- Question 8Multiple Select
Which components are part of the ReAct (Reasoning and Acting) framework loop?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DManual User Feedback
Why this is the answer
The ReAct framework follows an iterative loop of thought, action, and observation.
- Question 9Interactive
Identify the error in this few-shot reasoning pattern implementation.
- AMissing tool names
- BMissing reasoning stepsCorrect answer
- CToo many examples
- DIncorrect output format
Why this is the answer
Providing only Input/Output without Thought/Action fails to teach the underlying logic needed for generalization.
- Question 10Single Choice
What does task decomposition involve in agent development?
- ACombining multiple agents
- BSplitting goals into sub-problemsCorrect answer
- CIncreasing token importance
- DAutomating tool selection
Why this is the answer
Task decomposition is the strategic instruction to break a high-level goal into smaller, executable sub-problems.
- Question 11Multiple Select
Which of these are characteristics of 'Self-Reflection and Self-Correction'?
- AReviewing previous reasoningCorrect answer
- BClosed-loop reasoningCorrect answer
- CError recovery without humansCorrect answer
- DIncreasing context window size
Why this is the answer
Self-reflection involves reviewing reasoning for inconsistencies to allow recovery without human intervention.
- Question 12Interactive
In this ReAct loop, identify which part represents the 'observation'.
- AThe thought process
- BThe tool call
- CThe tool outputCorrect answer
- DThe user prompt
Why this is the answer
In ReAct, the observation is the output of the tool being fed back into the model's loop.
Cognition, Planning, and Memory
4 questions in this domain
- Question 13Single Choice
Which technique involves prompting an LLM to generate intermediate reasoning steps to solve complex problems?
- AChain-of-ThoughtCorrect answer
- BTask Decomposition
- CFew-Shot Prompting
- DSelf-Reflection
Why this is the answer
Chain-of-Thought (CoT) prompting specifically requires the model to generate a sequence of intermediate reasoning steps.
- Question 14Multiple Select
In the ReAct framework, which three components form the iterative loop used by an agent?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DInstruction
Why this is the answer
The ReAct framework consists of a 'thought' (reasoning), an 'action' (tool call), and an 'observation' (result).
- Question 15Interactive
Review the following few-shot example pattern. Is this pattern correctly designed for teaching reasoning logic?
- AYes, it includes Thought/Action/OutputCorrect answer
- BNo, it only provides Input/Output
- CNo, it lacks tool definitions
- DYes, it uses simple instructions
Why this is the answer
Effective few-shot reasoning for agents must include (Input/Thought/Action/Output) rather than just (Input/Output).
- Question 16Single Choice
What is the primary purpose of Task Decomposition in agentic AI workflows?
- ABreaking goals into sub-problemsCorrect answer
- BIncreasing context window size
- CReducing tool execution time
- DEliminating the need for CoT
Why this is the answer
Task Decomposition involves breaking a high-level goal into smaller, executable sub-problems to prevent the agent from becoming overwhelmed.
Deployment and Scaling
6 questions in this domain
- Question 17Single Choice
Which technique involves prompting an LLM to generate intermediate reasoning steps to break down complex problems?
- AChain-of-Thought (CoT)Correct answer
- BSimple Instruction
- CTask Decomposition
- DFew-Shot Learning
Why this is the answer
Chain-of-Thought (CoT) prompting improves reasoning by generating intermediate steps for complex problems.
- Question 18Multiple Select
In the ReAct framework, which components make up the iterative reasoning and acting loop?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DUser Input
Why this is the answer
ReAct combines reasoning traces (thought), task-specific actions (action), and results (observation).
- Question 19Interactive
Review the few-shot example provided in the code and identify why it might fail to teach complex logic.
- ALacks reasoning stepsCorrect answer
- BToo many examples
- CIncorrect tool names
- DMissing observations
Why this is the answer
Providing only Input/Output without Thought/Action steps fails to teach the underlying logic.
- Question 20Single Choice
What is the purpose of Self-Reflection and Self-Correction in autonomous agents?
- ATo recover from errorsCorrect answer
- BTo increase context window
- CTo select tools faster
- DTo reduce token usage
Why this is the answer
Self-reflection allows agents to review reasoning for inconsistencies and recover from failures.
- Question 21Multiple Select
Which of the following are considered common traps when designing agent reasoning?
- AConfusing CoT with simple instructionCorrect answer
- BOver-reliance on few-shotting without reasoningCorrect answer
- CMisidentifying the role of the observationCorrect answer
- DUsing task decomposition
Why this is the answer
The documentation identifies confusing CoT with instruction, poor few-shotting, and misidentifying observations as traps.
- Question 22Interactive
Look at the ReAct loop in the code. What is the 'observation' component?
- ATool outputCorrect answer
- BUser command
- CModel's thought
- DAgent's action
Why this is the answer
In ReAct, the observation is the result/output of the tool fed back into the model.
Evaluation and Tuning
6 questions in this domain
- Question 23Single Choice
Which technique involves prompting an LLM to generate a sequence of intermediate reasoning steps to solve complex problems?
- AFew-Shot Prompting
- BChain-of-Thought (CoT)Correct answer
- CTask Decomposition
- DSelf-Reflection
Why this is the answer
Chain-of-Thought (CoT) prompting improves reasoning by forcing the model to generate intermediate steps.
- Question 24Multiple Select
In the ReAct framework, which three components form the iterative loop used by the agent?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DInstruction
Why this is the answer
The ReAct framework combines reasoning (thought), task-specific actions, and observations from the environment.
- Question 25Interactive
Review the following few-shot example pattern. Is this pattern sufficient for teaching an agent complex logic?
- AYes, it includes Thought/Action/Output
- BNo, it only provides Input/OutputCorrect answer
- CYes, it uses simple instruction
- DNo, it lacks task decomposition
Why this is the answer
Providing only Input/Output fails to teach the agent the underlying logic; it needs Thought/Action/Output steps.
- Question 26Single Choice
What is the primary purpose of task decomposition in agentic workflows?
- ATo increase the context window size
- BTo prevent the agent from being overwhelmedCorrect answer
- CTo replace the need for CoT prompting
- DTo automate tool selection
Why this is the answer
Task decomposition prevents agents from being overwhelmed and ensures focus on verifiable objectives.
- Question 27Multiple Select
Which of the following are considered 'traps' when designing agent reasoning processes?
- AConfusing CoT with simple instructionCorrect answer
- BMisidentifying the role of the observationCorrect answer
- COver-reliance on few-shotting without reasoningCorrect answer
- DIncreasing the model parameter count
Why this is the answer
CoT vs simple instruction, observation role misidentification, and empty few-shotting are listed traps.
- Question 28Interactive
Analyze the ReAct loop logic in the code block. What role does the 'Observation' play?
- AA user-provided instruction
- BThe result of a tool being fed back into the modelCorrect answer
- CA reasoning step by the model
- DA high-level goal from the developer
Why this is the answer
In ReAct, the observation is the output of the tool being fed back into the model's reasoning loop.
Human-AI Interaction and Oversight
3 questions in this domain
- Question 29Single Choice
What is the primary purpose of the Chain-of-Thought (CoT) prompting technique in Large Language Models?
- AIncreasing context window size
- BGenerating intermediate reasoning stepsCorrect answer
- CProviding tool execution results
- DReducing total token usage
Why this is the answer
CoT improves reasoning by prompting the model to generate a sequence of intermediate steps to break down complex problems.
- Question 30Multiple Select
Which components are part of the iterative ReAct (Reasoning and Acting) framework loop?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DInstruction
Why this is the answer
The ReAct framework combines reasoning traces (thought), task-specific actions (action), and external results (observation).
- Question 31Interactive
Analyze the few-shot example provided in the code below. Which mistake was made in the reasoning pattern?
- AMissing observation
- BLack of reasoning stepsCorrect answer
- CToo many examples
- DIncorrect tool call
Why this is the answer
Providing only Input/Output pairs without Thought/Action steps fails to teach the underlying logic required for generalization.
Knowledge Integration and Data Handling
4 questions in this domain
- Question 32Single Choice
What is the primary goal of using Chain-of-Thought (CoT) prompting in large language models?
- AGenerate faster responses
- BProvide immediate final answers
- CBreak problems into manageable sub-tasksCorrect answer
- DIncrease the context window size
Why this is the answer
CoT allows the agent to break down complex problems into manageable sub-tasks via intermediate reasoning steps.
- Question 33Multiple Select
Which components are part of the ReAct (Reasoning and Acting) framework iterative loop?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DInstruction
Why this is the answer
The ReAct framework consists of a loop of thought (reasoning), action (tool call), and observation (result).
- Question 34Interactive
Review the few-shot example provided below and determine if it follows the correct reasoning pattern.
- ACorrect: Includes Thought/ActionCorrect answer
- BIncorrect: Missing Reasoning
- CIncorrect: Only uses Input/Output
- DCorrect: Uses only Tool Results
Why this is the answer
Few-shotting for agents must include reasoning steps (Input/Thought/Action/Output) rather than just Input/Output.
- Question 35Single Choice
In the ReAct framework, how should a student correctly identify the 'observation'?
- AInput provided by the user
- BThe model's internal thought
- CThe output of the tool callCorrect answer
- DThe final user instruction
Why this is the answer
The observation is the result of the tool being fed back into the model's reasoning loop.
NVIDIA Platform Implementation
3 questions in this domain
- Question 36Single Choice
Which statement best describes the primary purpose of Chain-of-Thought (CoT) prompting in Large Language Models?
- AIncreasing context window size
- BEnhancing reasoning via intermediate stepsCorrect answer
- CSpeeding up tool execution time
- DReducing the number of required tokens
Why this is the answer
CoT improves reasoning by prompting the model to generate a sequence of intermediate reasoning steps for complex problems.
- Question 37Multiple Select
In this scenario, which components are part of the ReAct (Reasoning and Acting) framework loop?
- AThoughtCorrect answer
- BActionCorrect answer
- CObservationCorrect answer
- DInstruction
Why this is the answer
The ReAct framework combines reasoning traces and actions through a loop of thought, action, and observation.
- Question 38Interactive
Review the few-shot example provided. What is missing to ensure the agent learns the underlying logic?
- AMissing Thought stepsCorrect answer
- BMissing Tool Name
- CMissing User ID
- DMissing Final Answer
Why this is the answer
Providing only Input/Output in few-shotting fails; it must include Thought/Action to teach reasoning logic.
Run, Monitor, and Maintain
3 questions in this domain
- Question 39Single Choice
Which framework uses an iterative loop of thought, action, and observation to allow an agent to adapt?
- AChain-of-Thought
- BReAct FrameworkCorrect answer
- CTask Decomposition
- DFew-Shot Reasoning
Why this is the answer
The ReAct framework combines reasoning (thought) and acting (action) in an iterative loop with observations.
- Question 40Multiple Select
Which of the following are considered key reasoning techniques for improving LLM agent capabilities?
- AChain-of-ThoughtCorrect answer
- BSelf-ReflectionCorrect answer
- CFIFO Token Management
- DSimple Instruction Following
Why this is the answer
Chain-of-Thought and Self-Reflection are core techniques for improving reasoning and error recovery in agents.
- Question 41Interactive
Examine the few-shot example below. Identify the missing component required for effective agent reasoning.
- AAction/Thought stepsCorrect answer
- BMore context window
- CLarger RAG chunks
- DHigher token priority
Why this is the answer
Few-shot examples must include Thought/Action steps, not just Input/Output, to teach underlying logic.
Safety, Ethics, and Compliance
3 questions in this domain
- Question 42Single Choice
In the ReAct framework, what is the specific definition of an 'observation'?
- AUser input
- BTool outputCorrect answer
- CModel reasoning
- DAction plan
Why this is the answer
In the ReAct framework, the observation is the result of a tool call being fed back into the model's reasoning loop.
- Question 43Multiple Select
Which techniques help an agent recover from errors without manual human intervention?
- ASelf-ReflectionCorrect answer
- BSelf-CorrectionCorrect answer
- CSimple Instruction
- DFIFO Token Management
Why this is the answer
Self-reflection and self-correction are closed-loop reasoning techniques that allow agents to recover from failures autonomously.
- Question 44Interactive
Identify the error in this few-shot example pattern for agent reasoning.
- AMissing ThoughtCorrect answer
- BMissing Action
- CMissing Observation
- DMissing Tool
Why this is the answer
Providing only Input/Output in few-shotting fails to teach the underlying logic; it must include the Thought/Action steps.
Frequently asked questions
Everything about the NVIDIA Certified Professional - Agentic AI question bank and how to use it.