#### 1. Define the goal (1–2 hours) Start by writing a one-page spec. Good specs answer: - What is the end-user outcome? (example: “Autonomous GitHub issue → PR agent that can clone, explore, edit, test, and submit”) - How many agents and what are their roles? - What tools does each agent need? (browser, code execution, vector search, Git CLI, etc.) - Success metrics: latency per turn, success rate on 50 real tasks, tokens per task, cost per task - Context length requirements (most agentic loops

NVIDIA Vibe Coding: Define State, Nodes & Edges Guide

Q: Pitfalls and guardrails?

**### What if my agents loop forever?** Add a hard max_turns (usually 15–25) and a reflection node that can decide to “finalize” or “escalate”. Nemotron 3 Super is good at self-critique; give it an explicit “decide_next_action” tool. **### What if token usage is higher than expected?** Use hierarchical summarization: after every 3–4 turns, run a short “compress context” call that distills history into 2–3 bullet points. This keeps you well under even 128k limits while preserving the 1M capab

Building Multi-Agent Systems with NVIDIA Nemotron 3 Super

Why this matters for builders
NVIDIA Nemotron 3 Super is a 120B-parameter open hybrid SSM-Latent MoE model (12B active parameters) that lets you run complex agentic AI systems at scale with up to 5× higher throughput and 2.2× faster inference than comparable dense models while maintaining strong reasoning accuracy (36 on AAIndex v4). It was purpose-built for Blackwell GPUs, supports 1M-token context, and ships with reference implementations for OpenCode, OpenHands, and OpenClaw. This combination removes the usual cost/quality trade-off that has blocked most indie and mid-size teams from shipping production-grade multi-agent workflows.

When to use it

You need multiple specialized agents that collaborate (researcher + coder + critic + executor)
Your workload involves long-running reasoning loops or tool-use chains
You want open weights + commercial-friendly licensing so you can self-host or use any inference provider
You are targeting high-volume inference on Blackwell, H100, or compatible cloud GPUs
You already use frameworks like LangGraph, CrewAI, AutoGen, or OpenHands

The full process

1. Define the goal (1–2 hours)

Start by writing a one-page spec. Good specs answer:

What is the end-user outcome? (example: “Autonomous GitHub issue → PR agent that can clone, explore, edit, test, and submit”)
How many agents and what are their roles?
What tools does each agent need? (browser, code execution, vector search, Git CLI, etc.)
Success metrics: latency per turn, success rate on 50 real tasks, tokens per task, cost per task
Context length requirements (most agentic loops stay under 128k, but 1M gives headroom for long codebases)

Starter prompt for your coding assistant (Claude 4 / Cursor / Windsurf):

You are an expert multi-agent system architect. Help me scope a production-grade agent using NVIDIA Nemotron 3 Super (120B hybrid MoE, 12B active, 1M context, optimized for Blackwell).

Project goal: [one sentence]
Target users: [describe]
Success criteria: [list 3–4 measurable KPIs]
Available tools: [list]
Preferred orchestration: LangGraph / CrewAI / OpenHands

Deliver:
1. Agent role breakdown
2. Information flow diagram (Mermaid)
3. Context management strategy (summary → tool results → reflection)
4. Estimated token usage per loop
5. Recommended inference backend (self-hosted vLLM + Nemotron or one of the hosted providers)

2. Choose your inference path (30 min)

Nemotron 3 Super is available on:

Baseten, Cloudflare, DeepInfra, Fireworks AI, FriendliAI, Inference.net, Lightning AI, Modal, Nebius, Together AI
Self-hosted on Blackwell via NVIDIA NIM or vLLM with the official model card on Hugging Face

Quick decision matrix you can paste into your notes:

- Need < 2s first-token latency on complex prompts → Fireworks or Together AI
- Want full control + lowest cost at scale → Self-host on Blackwell with vLLM + FP8
- Building a demo today → Modal or Lightning AI (easiest notebooks)
- Maximum context (close to 1M) → Check provider-specific limits (most cap at 128k–256k today)

3. Scaffold the project (45 min)

Use this folder structure:

nemotron-agent/
├── agents/
│   ├── researcher.py
│   ├── coder.py
│   ├── critic.py
│   └── executor.py
├── tools/
├── graph.py          # LangGraph or OpenHands workflow
├── prompts/
├── eval/
├── Dockerfile
├── requirements.txt
└── run.py

Copy-paste starter for graph.py (LangGraph + Nemotron):

from langgraph.graph import StateGraph, END
from langchain_nvidia_ai_endpoints import ChatNVIDIA
import os

llm = ChatNVIDIA(
    model="nvidia/nemotron-3-super",  # or the exact hosted model name
    temperature=0.2,
    max_tokens=4096,
    api_key=os.getenv("NVIDIA_API_KEY")
)

If you prefer OpenHands, clone the official Nemotron 3 Super example from NVIDIA’s GitHub repository (linked in the technical blog) and swap the model ID.

4. Implement the agents (2–4 hours)

Focus on concise, high-signal system prompts. Nemotron 3 Super’s hybrid architecture excels at tool-calling and multi-step reasoning, so lean into that strength.

Example system prompt template (researcher agent):

You are a world-class technical researcher using Nemotron 3 Super (120B hybrid MoE).
Your job is to gather facts, read documentation, and produce a concise evidence summary.
Always use tools when information is missing. Never hallucinate citations.
Current date: {{date}}
Available tools: {{tool_list}}

Repeat for each role. Keep temperature low (0.1–0.3) for tool-calling reliability.

5. Validate with realistic evals (3–6 hours)

Do not ship without quantitative benchmarks.

Create an eval/ folder with:

30–50 real tasks from your domain (GitHub issues, customer support tickets, research questions)
A simple evaluator script that measures:
- Task success (binary or rubric score)
- Average tokens per task
- Wall-clock time
- Number of tool calls

Starter eval script snippet:

import asyncio
from tqdm.asyncio import tqdm

async def evaluate_task(task, graph):
    start = time.time()
    result = await graph.ainvoke({"messages": [task]})
    latency = time.time() - start
    tokens = result.get("total_tokens", 0)
    success = judge_success(task, result["final_answer"])
    return {"success": success, "latency": latency, "tokens": tokens}

# Run 50 tasks and compute aggregates

Target: >75 % success rate on your validation set before moving to production.

6. Ship safely

Production checklist:

Rate limiting and cost guardrails (track spend per user/session)
Logging of every agent turn + tool call (store in ClickHouse or Postgres)
Human-in-the-loop escalation path for high-stakes actions
Observability (LangSmith, Helicone, or Phoenix)
A/B test against a smaller model (Nemotron 3 Nano or Llama-3.1-70B) to confirm ROI
Containerize with NVIDIA NIM or vLLM optimized Docker image for Blackwell

If you are self-hosting, start with FP8 quantization. The model was designed for Blackwell, so you will see the advertised 2.2× speedup and 5× throughput gains only on GB200 or B200 nodes.

Pitfalls and guardrails

### What if my agents loop forever?
Add a hard max_turns (usually 15–25) and a reflection node that can decide to “finalize” or “escalate”. Nemotron 3 Super is good at self-critique; give it an explicit “decide_next_action” tool.

### What if token usage is higher than expected?
Use hierarchical summarization: after every 3–4 turns, run a short “compress context” call that distills history into 2–3 bullet points. This keeps you well under even 128k limits while preserving the 1M capability for rare long-document cases.

### What if tool calling accuracy is low?
Lower temperature to 0.1, add few-shot examples of correct tool schemas in the system prompt, and use the newer OpenAI-compatible tool calling format that most Nemotron 3 Super endpoints support.

### What if I can’t afford Blackwell yet?
Use one of the hosted providers. Fireworks and Together AI already offer competitive pricing for the 120B MoE. Measure cost per successful task, not raw tokens.

What to do next

Pick one narrow agentic workflow (e.g. “bug → reproduction → fix PR”)
Ship a working prototype in < 8 hours using the OpenHands template
Measure baseline performance
Iterate on prompts and add one new tool per day
Once you have >80 % success, productize the human escalation flow and expose it to real users

Nemotron 3 Super finally makes high-quality open agentic infrastructure accessible to builders who want to own their stack. The hybrid SSM + Latent MoE design, combined with native 1M context and Blackwell optimizations, removes the usual excuses. Time to build.

(Word count: 1,187)

Sources

NVIDIA Blog: “New NVIDIA Nemotron 3 Super Delivers 5x Higher Throughput for Agentic AI” (https://blogs.nvidia.com/blog/nemotron-3-super-agentic-ai/)
NVIDIA Technical Blog: “Introducing Nemotron 3 Super: An Open Hybrid Mamba-Transformer MoE for Agentic Reasoning” (https://developer.nvidia.com/blog/introducing-nemotron-3-super-an-open-hybrid-mamba-transformer-moe-for-agentic-reasoning/)
NVIDIA Newsroom: “NVIDIA Debuts Nemotron 3 Family of Open Models”
VideoCardz coverage and official GitHub repository referenced in the announcement
Original X post by @ctnzr / @NVIDIAAIDev

Define your state, nodes, and edges...