Improve AI Code Generation with NVIDIA NeMo Agent Toolkit: A Test-Driven Agent Tutorial

Scaling laws are driving smarter AI systems across pre-training, post-training, and inference. While large-scale pretraining of large language models (LLMs) delivers strong results, it is difficult to scale further. Autonomous AI agents and test-time compute methods, such as those used by DeepSeek-R1, offer notable gains by scaling post-training and inference compute. These approaches are especially valuable for complex tasks such as logic, math, and coding. NVIDIA NeMo Agent Toolkit, an open-source library for connecting and optimizing teams of AI agents, makes these novel scaling methods easier to adopt by helping organizations design, test, deploy, and optimize agentic AI applications. This tutorial walks through building a test-driven AI code generation agent within the toolkit.

LLMs excel at coding tasks but are confined to a chat interface, lacking autonomy and real-world integration. AI agents built on these LLMs are designed to accomplish real-world goals. They interact with their environment through tools, memory, and planning to execute tasks such as editing files, running code, or searching for information, making them well suited to AI code generation workflows.

AI agents are one way to scale inference-time computation. Designing an agent or multi-agent system requires balancing flexibility against structure. A flexible agent may receive a shell, code editor, and web browser with minimal instruction, while a structured agent follows predefined steps, such as localizing a failing test and then iterating on code changes. Flow engineering, which defines states and transitions with an agent or tool executing within each state, is a popular middle ground. Reasoning models such as DeepSeek-R1 and OpenAI o1 explore multiple reasoning paths before answering, and search methods such as beam search explore multiple branches guided by a scoring function.

The toolkit addresses common challenges in evaluation, deployment, and optimization. It works with agent frameworks such as LangGraph and CrewAI, offers a common specification for reusability across projects via a registry, and provides an evaluation harness for rapid iteration by changing a configuration file. Built-in deployment options include launching microservices with aiq serve and an open-source chatbot-style interface. Optimization features include a workflow profiler, parallel tool calling, and integration with NVIDIA Dynamo. Observability is supported through integration with Phoenix, OpenTelemetry Collector, and custom providers.

To follow this tutorial, you need NVIDIA GPUs to run reasoning NIM microservices, the NVIDIA NeMo Agent Toolkit installed, and the LangGraph framework.

Begin by cloning the NVIDIA NeMo Agent Toolkit GitHub repository and installing the library following the README instructions. Then create a new project template with the aiq workflow create code_gen_example command. The toolkit unifies agentic workflows and callable tools under a single function class, so the code generation agent can be implemented as a function and used as a tool within a supervisor agent such as a ReACT agent, alongside other agents like research, error localization, or test generation agents.

The configuration file defines the entire workflow. It has three main sections: functions (tools accessible to agents), llms (models available to agents and tools), and workflow (the main entry point). The example sets the code_gen_tool function with a reasoning LLM (DeepSeek-R1) for debugging and a code generation LLM (Qwen2.5-Coder) for writing code, uses a general LLM (Llama 3.3 70B) for the ReACT workflow, and limits iterations to three. Models can be served through NVIDIA NIM via the NVIDIA API Catalog or hosted locally, and OpenAI and other providers are also supported. Changes to this file can be evaluated quickly with the aiq eval command.

The code generation function is registered in register.py using a config class and a registered async function. Internally, a LangGraph StateGraph runs four steps: the coding LLM generates a git patch resolving the issue; the updated code runs in a sandboxed test tool; if tests fail, the reasoning model proposes changes based on the output; and these steps repeat until tests pass or the iteration limit is reached. Each node is a Python function, and clear tool descriptions are critical so agents can interact effectively with one another.

The aiq run command executes the workflow from the configuration file with a problem statement, such as writing a function that computes the largest rectangle in a histogram, along with paths to test and solution files. Logs show the agent's reasoning, the generated code, test results, and debugging iterations. In the example run, the first attempt failed to handle empty input, the reasoning model identified the issue, and the second attempt passed all tests, demonstrating the iterative test-driven loop.

Additional capabilities such as web search or calculator use can be added to the supervisor agent simply by listing functions in the configuration file, using tools provided in the Agent Toolkit tools folder. Code generation is a strong candidate for test-time compute scaling because correctness can be verified. Reasoning LLMs like DeepSeek-R1 guide the debugging process, and tool use, memory, and planning can further improve the system. The NeMo Agent Toolkit simplifies building agentic systems through reusable components, orchestrating models, frameworks, and tools for complex real-world tasks. Developers can explore the profiler, join the Agent Toolkit Hackathon, and build hands-on skills with the open-source toolkit.