NVIDIA Agentic AI

An agent is only as good as its next decision. This module covers how agents break a goal into steps, recover when a step fails, and hold on to what they have learned across a session and beyond it.

• Reasoning strategies and when each one helps
• Decomposing a goal into a plan
• Replanning after a failed step
• Short-term, long-term and shared memory
• Keeping context small enough to stay useful

You build A planning agent that recovers from a failed tool call without starting over.

Connect agents to the outside world. You define tools a model can use correctly, engineer prompts that hold up across inputs, and handle text, images and structured data in the same system.

• Designing tools a model can call reliably
• Prompt engineering for agents
• Structured output and schema validation
• Handling multimodal input
• Retries, timeouts and failing safely

You build A multimodal agent with its own tool set and validated outputs.

Most agents are limited by what they can find. Here you build retrieval pipelines end to end, from preparing messy data to ranking results, and you learn to measure whether retrieval is actually helping.

• Preparing and chunking varied data
• Embeddings and vector search
• Hybrid search and reranking
• Grounding answers in sources
• Measuring retrieval quality

You build A retrieval pipeline over real documents, with a quality report.

Several agents can do what one cannot, and they add new ways to fail. You design how agents hand off work, share state and resolve conflicts, and you learn to keep a team of agents debuggable.

• Supervisor, peer and pipeline topologies
• Handoffs and shared state
• Communication protocols between agents
• Resolving conflicting outputs
• Tracing work across agents

You build A team of specialist agents that completes one task together.

A demo proves nothing. You build evaluation sets, compare agents against each other, and use the results to tune prompts, models and tools, so that a change is backed by evidence rather than a good impression.

• Building an evaluation set from real tasks
• Measuring task success, cost and latency
• Comparing agents and models fairly
• Tuning prompts, tools and parameters
• Catching regressions before release

You build An evaluation harness that scores every change to an agent.

Put NVIDIA’s hardware and software to work for agents. You learn how accelerated inference changes what is affordable, how to serve models through NVIDIA’s tools, and where the stack fits in a wider system.

• Inference on GPUs: throughput against latency
• Serving models with NVIDIA NIM
• Optimizing a model for inference
• Fitting the stack into an existing system
• Reading cost and capacity numbers

You build An agent served on NVIDIA’s inference stack, with measured performance.

Move from a notebook to a service. This module covers packaging an agentic system, rolling out changes safely, and scaling under real load without letting cost or latency run away.

• Packaging agents as services
• Scaling stateful and stateless parts
• Caching and batching to control cost
• Rolling out changes with canaries
• Planning capacity for uneven load

You build A deployed agent service with a safe rollout and rollback path.

Agents drift once they meet real users. You instrument a live system, read its traces, troubleshoot problems you did not predict, and set up the routines that keep it improving after launch.

• Tracing and logging agent decisions
• Dashboards for quality, cost and latency
• Detecting drift and silent failure
• Debugging a bad run from its trace
• Feeding production data back into evaluation

You build A monitoring setup that raises an alert when agent quality drops.

An agent that acts can cause real harm. You learn the main risks, from prompt injection to data leaks, and put guardrails in place that hold up under pressure while meeting legal and regulatory duties.

• Threats to agents: prompt injection and misuse
• Input and output guardrails
• Limiting what an agent is allowed to do
• Privacy and data handling
• Meeting compliance requirements

You build A guardrail layer tested against a set of attacks.

People stay accountable for what agents do. This module covers designing the points where a person reviews, approves or takes over, and interfaces that make an agent’s reasoning clear enough to trust or to overrule.

• Choosing where humans must approve
• Escalation and handover design
• Showing an agent’s reasoning to its users
• Collecting feedback people will actually give
• Staying accountable for automated decisions

You build A human-in-the-loop workflow with clear approval and takeover points.

Everything meets in one system. You design, build, evaluate and deploy an agentic application for a real problem, then defend your choices on architecture, cost, safety and oversight, the way you would at work.

• Scoping a real problem and its constraints
• Choosing the architecture and the stack
• Building and evaluating the system
• Deploying and monitoring it
• Presenting and defending the design

You build A complete agentic system, deployed, measured and documented.