Build a Report Generator AI Agent with NVIDIA Nemotron on OpenRouter

TL;DR

• A self-paced workshop demonstrates how to build a four-component, LangGraph-based AI agent for automated report generation using NVIDIA Nemotron on OpenRouter.
• The architecture includes a researcher component implementing a ReAct-style reasoning loop, an author component for writing sections, and an agent coordinator that strings the workflow together; a gating function can trigger additional research as needed.
• Core model power comes from NVIDIA NIM endpoints accessible via a ChatNVIDIA Connector operating on OpenRouter; Tavily is used as the primary information-gathering tool.
• The workflow is implemented with references to code modules (prompts.py, researcher.py, author.py, agent.py) and notebooks, with the final output rendered in Markdown.
• The program also features a Nemotron Labs Livestream and self-paced tutorials to help developers adopt agentic AI for documents.

Context and background

AI agents are autonomous systems that use large language models to make decisions, adapt to changing requirements, and perform complex reasoning. The NVIDIA Dev Blog workshop provides a self-paced path to build a report generation agent and to explore related components and workflows NVIDIA Dev Blog. To run along, developers must configure project secrets using the Secrets Manager tile under the NVIDIA DevX Learning Path in the JupyterLab Launcher and verify in the logs that the secrets have been added successfully. The workshop guides users to the Introduction to Agents tile to begin. The material emphasizes how agents differ from simpler AI applications by enabling dynamic tool use, advanced reasoning, and adaptive analysis strategies. The workshop outlines four key considerations fundamental to all agents and then walks through building a basic calculator-equipped agent as a starting point in code/intro_to_agents.ipynb. The practical goal is an agent capable of completing a multi-step document-generation task. The centerpiece of the workshop is a multi-layered agentic system that runs with LangGraph and NVIDIA NIM hosted as an OpenRouter endpoint. The architecture features four interconnected agentic components that handle specific aspects of document generation. The core model powering the agent comes from NVIDIA NIM endpoints, which provide high-performance inference capabilities. The integration uses a ChatNVIDIA Connector that operates with NVIDIA NIM hosted as an OpenRouter endpoint. Prompts used in the workflow illustrate reliable LLM prompting principles: the agent’s capabilities are defined through its tools, and a primary information-gathering tool is Tavily, a search API designed specifically for AI agents. Architectural decisions in the tools module are described in the workshop materials. The researcher component implements the ReAct reasoning and action pattern, creating a loop where the agent thinks, acts, and then decides the next steps. The code for this component is in code/docgen_agent/researcher.py and is testable via code/researcher_client.ipynb, which also shows each action, tool call, tool output, and the final summary. As a complement to ReAct, a gating function was introduced before the React-style agent to determine whether additional research is required, followed by a writing step at the end. The author component is implemented in code/docgen_agent/author.py and can be tested with code/author_client.ipynb, which similarly shows each action and the final written section in Markdown format. The full agent workflow combines these pieces into a linear, yet extensible, document-generation process, culminating in a finalized report generated in Markdown. LangGraph is presented as an agent framework for advanced state management and flow control, connecting the components into a single navigable graph of nodes and edges. The workshop demonstrates how to map components to LangGraph nodes and how to route intermediate outputs between steps. By following along, developers gain hands-on experience with production-grade tools and techniques for building agentic AI systems. The full workflow and code are tested via code/agent_client.ipynb. A sample research report produced by the agent is included in the workshop materials as sample markdown output. Beyond the workshop itself, NVIDIA invites participants to join the Nemotron Labs Livestream, Building an AI Agent for Report Generation with NVIDIA Nemotron on OpenRouter, and to stay updated on Agentic AI, Nemotron, and related topics by subscribing to NVIDIA news and following NVIDIA AI on social media. Explore the self-paced video tutorials and livestreams in the learning materials. For hands-on learning, tips, and tricks, join the Nemotron Labs Livestream on Tuesday, September 16th at 11am PT. Stay up to date on Agentic AI, Nemotron, and more by subscribing to NVIDIA news, joining the community, and following NVIDIA AI on LinkedIn, Instagram, X, and Facebook. Explore the self-paced video tutorials and livestreams in the learning path. NVIDIA Dev Blog

What’s new

The workshop introduces a multi-layered agentic system deployed with LangGraph and NVIDIA NIM hosted as an OpenRouter endpoint. The architecture features four interconnected components that handle distinct parts of the document generation process:

• A researcher component that implements the reasoning-action loop (ReAct).
• An author component that writes sections of the report.
• An agent component that coordinates the overall workflow and routing of data between steps.
• A gating mechanism added before the React-style agent to decide whether further research is needed, plus a concluding writing step. The core model powering the agent runs on NVIDIA NIM endpoints and is accessed via a ChatNVIDIA Connector using OpenRouter. Tavily serves as the primary tool for information gathering within the workflow, and the prompts for the agent are defined in code/docgen_agent/prompts.py. The codebase relies on modular components, each testable via notebooks such as code/researcher_client.ipynb, code/author_client.ipynb, and code/agent_client.ipynb. A sample research report generated by the agent is provided in the workshop materials as sample markdown output. LangGraph provides a visual and architectural framework to connect the components, mapping each module to a node in the graph and routing intermediate outputs along edges. The workshop guides developers through assembling the complete agent from the foundational concepts to a functioning, Markdown-based report generator. The goal is to deliver a production-grade workflow that can be tested and extended in a hands-on manner. NVIDIA Dev Blog

Why it matters (impact for developers/enterprises)

For developers, the workshop demonstrates how autonomous agents can dynamically select tools, perform layered reasoning, and adapt their approach based on the task at hand. The combination of LangGraph for state management and NVIDIA NIM for high-performance inference on OpenRouter enables a scalable, modular architecture for document-generation tasks. The presence of a ReAct-based researcher, an author module, and an orchestration agent provides a practical blueprint for building more complex, multi-step workflows that automate knowledge work. For enterprises, the approach offers a framework to deploy robust, tool-using agents that can handle complex tasks such as report generation with minimal hard-coded flows. By using production-grade endpoints and a modular architecture, teams can iteratively improve the agent by swapping tools, refining prompts, and adjusting routing logic without reworking the entire system. The self-paced nature of the workshop, together with live streams and tutorials, helps practitioners stay current with agentic AI trends and tooling. NVIDIA Dev Blog

Technical details or Implementation

Foundational considerations

• The workshop emphasizes understanding what differentiates agents from simpler LLM-based applications: agents can dynamically choose tools, perform complex reasoning, and adapt their analysis.
• Four key considerations fundamental to all agents are introduced, forming the basis for building the initial calculator-equipped agent in code/intro_to_agents.ipynb. Tools and endpoints
• NVIDIA NIM endpoints power the core model, enabling high-performance inference.
• The ChatNVIDIA Connector uses NVIDIA NIM hosted as an OpenRouter endpoint to route model calls.
• Tavily is used as the primary information-gathering tool for agent-enabled search tasks.
• Secrets required for the workshop are configured via the Secrets Manager tile under NVIDIA DevX Learning Path in the JupyterLab Launcher; the logs tab should confirm successful secret addition. Code, components, and notebooks
• The researcher component implements the ReAct reasoning and action pattern; this code is in code/docgen_agent/researcher.py and testable via code/researcher_client.ipynb, which shows each action, tool call, tool output, and final message.
• The author component, responsible for section writing, is in code/docgen_agent/author.py and testable via code/author_client.ipynb, with visibility into actions and final markdown output.
• The main agent workflow is implemented in code/docgen_agent/agent.py and testable via code/agent_client.ipynb; the final output is a markdown-formatted report.
• The architecture integrates these components with LangGraph to illustrate the nodes and the routing between them. State management and routing
• LangGraph is presented as the framework to manage state and control flow across the four components, enabling clear mapping from components to graph nodes and edges that route intermediate results. Testing and artifacts
• A sample research report demonstrates the agent’s output in markdown.
• The workshop provides notebooks to test each component and to observe actions, tool calls, and results along the workflow. Live learning and references
• A Nemotron Labs Livestream titled Building an AI Agent for Report Generation with NVIDIA Nemotron on OpenRouter is scheduled, along with self-paced video tutorials and livestreams to deepen understanding.

Key takeaways

• Agents differentiate themselves from traditional LLM apps by dynamically selecting tools and reasoning steps.
• A four-component architecture can support robust, end-to-end document generation powered by high-performance NVIDIA NIM endpoints.
• LangGraph provides a practical approach to state management and routing in complex agent workflows.
• Tavily serves as the primary information source for agent-driven searches within the workflow.
• The workshop emphasizes practical implementation details, including Prompts in prompts.py and test notebooks for researchers, authors, and agents.
• Secrets management and proper environment setup are essential for running the workshop in a JupyterLab environment.
• The program is complemented by a live Nemotron Labs Livestream and ongoing self-paced tutorials to facilitate adoption.

References

• https://developer.nvidia.com/blog/build-a-report-generator-ai-agent-with-nvidia-nemotron-on-openrouter/