Skip to content
Back to search

workshop-build-an-agent

The Build An Agent Workshop is a comprehensive, hands-on learning experience that teaches you how to create, deploy, and evaluate AI agents using NVIDIA technology. Through seven progressive modules,…

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/brevdev--workshop-build-an-agent/badge.svg)](/listings/brevdev--workshop-build-an-agent)

HTML

<a href="/listings/brevdev--workshop-build-an-agent"><img src="/api/listings/brevdev--workshop-build-an-agent/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 166 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Build An Agent Workshop [![ Click here to deploy.](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-32kC34ErT9wsqTcJyaKMxBEuhr2) [![Open In AI Workbench](https://img.shields.io/badge/Open_In-AI_Workbench-76B900)](https://ngc.nvidia.com/open-ai-workbench/aHR0cHM6Ly9naXRodWIuY29tL2JyZXZkZXYvd29ya3Nob3AtYnVpbGQtYW4tYWdlbnQ=)
  2. The Build An Agent Workshop is a comprehensive, hands-on learning experience that teaches you how to create, deploy, and evaluate AI agents using NVIDIA technology. Through seven progressive modules, you'll build intelligent systems that can perform complex tasks, learn to implement Retrieval Augmented Generation (RAG), and master the art of evaluating, improving, and securing agent performance.
  3. This workshop provides everything you need to become proficient in agentic AI development:
  4. * **Module 1 - Build an Agent**: Create a Report Generation Agent that researches topics and writes comprehensive reports
  5. * **Module 2 - Agentic RAG**: Build an IT Help Desk agent using RAG with NVIDIA NeMo Retriever
  6. * **Module 3 - Agent Evaluation**: Learn to measure and improve agent quality using RAGAS metrics and LLM-as-a-judge techniques
  7. * **Module 4 - Agent Customization**: Customize your agent beyond prompt engineering and tools with agent skills and reinforcement learning (RL).
  8. * **Module 5 - Deep Agents**: Build deep agents that autonomously handle complex, multi-step tasks—and use sandboxing to restrict their access.
  9. * **Module 6 - Agent Safety**: Secure autonomous agents with kernel-level enforcement (via OpenShell) and privacy routing using NVIDIA's NemoClaw stack.
  10. * **Module 7 - Agent Harnesses & Skills**: Separate the harness layer from the LLM, survey harness architectures from OpenClaw to pi to Claude Code, and supercharge any of them with portable, GPU-accelerated NVIDIA Verified Skills.
  11. At the end of this workshop, you will take home:
  12. * Deep understanding of agent architecture and design patterns
  13. * Working agents and evaluation workflows demonstrating different capabilities
  14. * Knowledge of NVIDIA NIM, NeMo models, and evaluation tools
  15. * Comprehensive evaluation framework for production agents
  16. * A turn-key, portable development environment
  17. * Best practices for continuous agent improvement
  18. The entire workshop can take anywhere from 14 to 21 hours to complete, depending on depth of exploration.
  19. ## Check your setup
  20. Open **Workshop Utilities → Workshop Health** in the JupyterLab launcher to check your environment, keys, model endpoints, and local services. Use **Secrets Manager** in the same section to save or update keys.
  21. To start a module over, close its notebooks and run `python code/workshop_support/reset.py <module number>` in a terminal. It copies your exercise files to `~/workshop-backups/`, restores them from git, and stops the module's servers. It shows what it will do and asks first.
  22. ## 🤖 Learn with an AI tutor (optional)
  23. This repo ships a set of **Agent Skills** that turn a coding agent into a hands-on workshop tutor. It explains each module's concepts in the workshop's own framing, gives **graduated hints — without ever completing your exercises or revealing answer keys** — interprets agent behavior, and troubleshoots the environment. It's an optional companion to the notebooks; you stay in the driver's seat.
  24. The skills work in **either harness** — use whichever you prefer. Same content; the Agent Skills format is cross-harness. Only the way you *invoke* a skill differs:
  25. - **Claude Code** reads them from `.claude/skills/` — invoke with a slash, e.g. `/workshop`, `/module-3`.
  26. - **Codex** reads them from `.agents/skills/` — invoke with a dollar sign, e.g. `$workshop`, `$module-3` (or run `/skills` to pick from a menu).
  27. In **both**, you can also just describe what you need (e.g. "help me with Module 3") and the matching skill loads automatically.
  28. **Available skills:** `workshop` (overview + router), `module-1` … `module-7` (one per module), and `setup-workshop` (local install helper) — prefix with `/` in Claude Code or `$` in Codex.
  29. **Two ways to use it — pick whichever fits how you're running the workshop:**
  30. 1. **Inside DevX-Lab (nothing to install).** Both `claude` and `codex` are preinstalled in the workshop container. Open a **Terminal** in JupyterLab — or, on desktop AI Workbench, the bundled **VS Code** app — and run **either** harness:
  31. - `claude` — on first launch paste an **Anthropic API key** (get one at <https://console.anthropic.com>), or
  32. - `codex` — on first launch sign in with `codex login` (ChatGPT account) or set `OPENAI_API_KEY`.
  33. This harness credential is separate from your NVIDIA key. Then start the tutor — in **Claude Code** type `/workshop` to get oriented (or `/module-3`); in **Codex** type `$workshop` (or `$module-3`, or run `/skills` to pick from a menu). The skills load automatically because you're running inside the project. *(If a CLI isn't found — e.g. an older build — run `sudo npm install -g @anthropic-ai/claude-code` or `sudo npm install -g @openai/codex` once.)*
  34. 2. **Against a local clone.** Prefer your own machine/editor? Install your harness (`npm install -g @anthropic-ai/claude-code` **or** `npm install -g @openai/codex`), clone this repo, and run `claude` or `codex` from the repo root — the skills load automatically.
  35. > **What the tutor will and won't do:** it's *guide-only* by design — it won't run GPU training, drive the live agent/sandbox/red-team, or fill in exercise blanks for you. Genuine setup/environment problems (keys, Docker, a broken control plane, OOM) it *will* help you fix directly.
  36. >
  37. > *Persistence:* the container persists each harness's settings and memory across rebuilds. Claude Code keeps credentials outside its volume, so you'll re-enter the Anthropic API key after a rebuild; Codex stores auth inside `~/.codex/`, so a single `codex login` persists across rebuilds.
  38. ## Workshop Modules
  39. ### Module 1: Build an Agent (1-2 hours)
  40. Learn the fundamentals of AI agents by building a Report Generation Agent from scratch.
  41. **What you'll build**: An intelligent system that researches any topic, creates outlines, writes detailed sections, and compiles professional reports automatically.
  42. **Key concepts**:
  43. - The four core components of any AI agent (Model, Tools, Memory, Routing)
  44. - ReAct architecture for tool-calling agents
  45. - Building agents from scratch and with LangChain
  46. - Using NVIDIA Nemotron models
  47. ### Module 2: Agentic RAG (2-3 hours)
  48. Evolve from basic RAG to intelligent agentic RAG systems.
  49. **What you'll build**: An IT Help Desk agent that dynamically decides when and how to search knowledge bases to answer user queries.
  50. **Key concepts**:
  51. - Traditional RAG limitations and how agents solve them
  52. - NVIDIA NeMo Retriever (embeddings and reranking)
  53. - Vector databases with FAISS
  54. - ReAct agents with retrieval tools
  55. ### Module 3: Agent Evaluation (2-3 hours)
  56. Master the art of measuring and improving agent performance.
  57. **What you'll learn**: How to systematically evaluate agents using industry-standard metrics, LLM-as-a-judge techniques, and NVIDIA models.
  58. **Key concepts**:
  59. - RAGAS metrics for RAG evaluation (faithfulness, relevancy, context precision/recall)
  60. - LLM-as-a-judge with NVIDIA models
  61. - Building automated evaluation pipelines
  62. - Continuous improvement strategies
  63. - Production monitoring best practices
  64. ### Module 4: Agent Customization (3-4 hours)
  65. Specialize agents for specific domains using synthetic data and reinforcement learning.
  66. **What you'll build**: A bash agent customized into a LangGraph CLI expert using NVIDIA NeMo Data Designer for synthetic data generation and GRPO (Group Relative Policy Optimization) for training.
  67. **Key concepts**:
  68. - When to use training vs. prompt engineering vs. tools
  69. - Synthetic data generation with NeMo Data Designer
  70. - Verifiable reward functions with NeMo Gym
  71. - GRPO training for exploration-based learning
  72. - Human-in-the-loop safety for command execution agents
  73. ### Module 5: Deep Agents (1-2 hours)
  74. Build autonomous agents that handle complex, multi-step tasks with planning and delegation.
  75. **What you'll build**: A deep-agent prototype with planning, sub-agent delegation, file-backed memory, and Docker sandboxing.
  76. **Key concepts**:
  77. - The four pillars of deep agents (planning, delegation, memory, skills)
  78. - Shallow vs. deep agent architectures
  79. - Sandboxing and security for autonomous agents
  80. - Using NVIDIA NIM models with the deepagents library
  81. - Production isolation patterns (Docker, resource limits)
  82. ### Module 6: Agent Safety (2-2.5 hours)
  83. Secure autonomous agents with kernel-level enforcement, data routing, and continuous safety evaluation.
  84. **What you'll build**: An OpenClaw personal assistant agent that executes inside and outside of an Openshell sandbox, complete with network and filesystem policies that demonstrate how the NVIDIA NemoClaw reference stack improves agent security.
  85. **Key concepts**:
  86. - How approval (M4), container controls (M5), and kernel restrictions work together
  87. - Setting up and running an OpenClaw autonomous agent
  88. - Kernel-level enforcement with OpenShell (Landlock LSM, seccomp BPF, OPA proxy)
  89. - Improved security for routing inference via a privacy router
  90. - Red-team testing with adversarial probes
  91. - Safety evaluation using LLM-as-judge (extending M3's evaluation framework)
  92. - The NemoClaw reference architecture (OpenClaw + OpenShell + Nemotron + Privacy Router)
  93. ### Module 7: Agent Harnesses & Skills (2-3 hours)
  94. Understand the harness layer that turns a stateless LLM into a capable agent — and the open skills format that makes capability portable across every harness.
  95. **What you'll build**: A minimal pi-style harness from scratch (four tools, sub-1k-token prompt), a context-tax measurement suite with lazy skill loading, a portable skill that runs unchanged in your harness and OpenClaw, and a GPU-accelerated agent powered by the NVIDIA-verified cuDF skill.
  96. **Key concepts**:
  97. - The harness vs. LLM separation, and the five things harnesses own (memory, self-evolution, skills, tool calling, token efficiency)
  98. - The harness landscape and philosophies: OpenClaw, Hermes, OpenCode, LangChain Deep Agents, pi, Claude Code, and Codex
  99. - The context tax, and lazy skill loading as token efficiency in action
  100. - The open Agent Skills specification and skill authoring
  101. - NVIDIA Verified Skills (github.com/NVIDIA/skills): signature verification, skill cards, and capability governance
  102. - Driving your local GPU from inside any harness — open source or closed
  103. ## Learning Objectives
  104. By the end of this workshop, you'll know how to:
  105. - **Build agents** that use tools, maintain context, and make intelligent decisions
  106. - **Implement RAG systems** that dynamically retrieve and use information
  107. - **Evaluate agent quality** using quantitative metrics and qualitative assessment
  108. - **Use NVIDIA technology** including NIM, Nemotron models, and NeMo Retriever
  109. - **Customize agents** through synthetic data generation and reinforcement learning
  110. - **Build deep agents** with planning, delegation, and sandboxed execution
  111. - **Secure agents** with kernel-level enforcement, data classification, and red-team evaluation
  112. - **Choose and extend agent harnesses** using the context-tax framework and portable, NVIDIA-verified skills
  113. - **Deploy and monitor** agents in production environments
  114. - **Continuously improve** agent performance through systematic evaluation

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.