NVIDIA released Nemotron 3.5 Lightning on August 11, 2026, a 30B parameter open model that only activates 3B parameters per token. It scores 51.56% on SWE-bench Verified, completes 10,000 tasks 30% faster than comparable models, has a 1 million token context window, and you can run it locally right now with one command. This is not just a new model. It is a signal that the most important AI competition of the next three years is efficiency, not scale.
The Question That Changes Everything
How many parameters does an AI model need to answer this question:
“What is the name of the variable declared on line 47 of this file?”
Not 70 billion. Not 30 billion. Not even 7 billion.
A model needs exactly as much intelligence as the question requires. And most of what AI agents actually do, reading files, calling tools, validating outputs, routing to subagents, checking whether a command succeeded, is nowhere near as hard as the questions we use frontier models to answer.
This is the insight behind NVIDIA’s Nemotron 3.5 Lightning. And it is the insight that might define the next three years of AI development more than any benchmark, any parameter count, or any frontier model release.
What Is Nemotron 3.5 Lightning?
NVIDIA released Nemotron 3.5 Lightning on August 11, 2026. Here is what it is in plain terms:
An open, 30B-parameter Mixture-of-Experts model that only activates 3B parameters per token, built specifically for the high-volume execution layer of always-on AI agents.
Let me unpack each part of that sentence because every word matters.
Open: weights, training data, and recipes are all released under the OpenMDW-1.1 licence. You can download it, run it, fine-tune it, and deploy it commercially. No API required. No vendor lock-in.
30B parameters: the model has 30 billion parameters total. This is comparable to large, capable models that normally require significant compute to run.
But only 3B active per token: here is the trick. At any given moment, only 3 billion parameters are actually doing computation. The rest are dormant.
Built for agent execution: this is not a general-purpose chatbot. It is engineered for the specific, repetitive, high-volume work that dominates real agent workloads.
The Efficiency Problem Nobody Talks About
To understand why Nemotron 3.5 Lightning matters, you need to understand the problem it solves.
Picture a real AI coding agent working on a task:
Step 1: Read project structure ← Simple: list files
Step 2: Understand the architecture ← Complex: reason across codebase
Step 3: Read the failing test output ← Simple: extract error message
Step 4: Locate the relevant function ← Medium: search and identify
Step 5: Understand the bug ← Complex: reason about logic
Step 6: Edit the file ← Simple: make the change
Step 7: Run the tests ← Simple: execute command
Step 8: Read test output ← Simple: parse result
Step 9: Confirm success or iterate ← Medium: evaluate outcome
Steps 2 and 5 genuinely need a powerful reasoning model. Steps 1, 3, 6, 7, and 8 could be handled by something far simpler, and much cheaper.
But most agentic systems today route every single step to the same frontier model. You pay GPT-5 pricing to read a file listing. You pay Claude Opus pricing to check whether a command returned exit code 0.
This is enormously wasteful. NVIDIA estimates that long-running agents spend most of their token budget on tool calls, result validation, and subagent delegation, not on the hard reasoning steps.
Nemotron 3.5 Lightning is built specifically for that majority of the work. The steps that do not need a frontier model. The steps that need a fast, accurate, cheap execution layer.
How Mixture-of-Experts Actually Works
The 30B-total / 3B-active magic comes from an architecture called Mixture-of-Experts (MoE). Here is the intuition:
Imagine a hospital. It has 30 specialist doctors on staff, cardiologists, neurologists, radiologists, orthopaedic surgeons, and so on. When a patient arrives, a triage nurse (the “router”) quickly assesses the case and sends them to the 2-3 relevant specialists.
Every patient does NOT see all 30 doctors. Most patients see 2-3. The hospital has the capacity of 30 specialists but the cost per patient is much lower.
MoE works the same way inside a neural network:
Normal dense model:
Token → All 30B parameters process it → Output
Cost: Always 30B parameters of compute
MoE model:
Token → Router examines token → Selects 2-3 "expert" sub-networks
→ Only those experts process the token → Output
Cost: Only 3B parameters of compute (the active experts)
The router learns, during training, which experts are good at which types of content. Some experts become specialists in code. Others in natural language. Others in structured data. The router learns to dispatch intelligently.
The result: the model has the knowledge capacity of a 30B model, but the inference cost of a 3B model, for most tokens.
The Architecture: LatentMoE and Mamba-2 and Attention
Nemotron 3.5 Lightning does not use a standard transformer architecture. It uses a hybrid:
Mamba-2 layers: these are state-space model layers that process sequences much more efficiently than standard attention for routine tokens. They do not compute full attention across the entire context at every step. This is what makes the 1 million token context window practical, not just theoretical.
Attention layers (selective): standard transformer attention for tokens where full cross-sequence reasoning matters. Used selectively, not at every layer.
MoE layers (LatentMoE): the expert routing mechanism that activates only the necessary subset of parameters per token.
The combination is deliberate. For most tokens in an agent workflow, reading tool outputs, processing structured data, following instructions, Mamba-2 is fast and efficient. For the tokens where complex cross-context reasoning matters, attention kicks in. The expert routing ensures only relevant specialised knowledge is activated throughout.
This architecture is why Nemotron 3.5 Lightning can claim up to 4x output speed compared to similar-sized models, while still scoring competitively on hard benchmarks.
The Real Benchmark Numbers
Let us look at what the model actually scores on things that matter:
|
Benchmark |
Score |
What It Measures |
|---|---|---|
|
SWE-bench Verified |
51.56% |
Real GitHub issues solved autonomously |
|
SWE-bench Multilingual |
39.33% |
Real issues across multiple languages |
|
PinchBench |
85.37% |
10,000 agentic tasks at speed |
|
GPQA Diamond |
75.44% |
Graduate-level scientific reasoning |
|
MMLU Pro |
81.94% |
Professional knowledge breadth |
|
Artificial Analysis Intelligence Index |
24 |
(+9 vs Nemotron 3 Nano’s 15) |
The number that matters most for practical deployment is the PinchBench result: completing 10,000 tasks 30% faster than Qwen3.6-35B at comparable accuracy.
Not 30% faster on one benchmark. 30% faster on 10,000 real agentic tasks. That is the workload that reflects real-world agent deployment, continuous, high-volume, diverse tasks.
The GPQA Diamond score (75.44%) is also worth noting. Graduate-level scientific reasoning at this parameter efficiency is genuinely impressive, it means the model is not just fast at routine tasks but capable of real reasoning when needed.
For context on SWE-bench: this benchmark takes real GitHub issues from popular open-source projects and asks the model to solve them autonomously. 51.56% means the model correctly fixed more than half of real software bugs without human help. Six months ago, that number required a frontier model.
NeMo Switchyard: The Other Half of the Story
NVIDIA did not release just the model. They released the model alongside NeMo Switchyard, an open-source routing library that makes Nemotron 3.5 Lightning dramatically more useful in practice.
NeMo Switchyard solves the orchestration problem. In a real agent workflow, different steps have different complexity requirements. Switchyard routes each step to the right model automatically:
Agent Task
↓
NeMo Switchyard (router)
↓ ↓
Simple execution steps: Complex planning/reasoning steps:
Nemotron 3.5 Lightning → Nemotron 3 Ultra / GPT-5.6
- Tool calls - Architecture decisions
- File reads - Multi-step planning
- Output validation - Novel problem solving
- Command execution - Code design
- Result checking - Security analysis
This is the system-of-models architecture that serious AI deployments are moving toward. Not one frontier model doing everything. A hierarchy where expensive intelligence is used only where it is genuinely needed, and fast, cheap execution handles the rest.
The economics are significant. If 80% of your agent’s token budget goes to routine execution work, and you replace that 80% with Nemotron 3.5 Lightning instead of a frontier model, your per-task cost drops dramatically, while the frontier model still handles the 20% of decisions that genuinely need it.
Who Is Already Using It
NVIDIA launched with production deployments from day one:
CrowdStrike: using Nemotron 3.5 Lightning for high-volume cybersecurity agent workflows. Security monitoring at scale requires processing millions of events. Routing each event to a frontier model is economically impossible. Lightning handles the execution layer.
Harvey with Trajectory: legal services. AI agents reviewing contracts, researching precedents, flagging clause variations. High-volume, requiring both accuracy and speed.
CodeRabbit with Baseten: automated code review. CodeRabbit reviews pull requests continuously. Routing every file read and diff analysis to a frontier model is cost-prohibitive. Lightning handles the bulk of the execution.
The pattern across all three: high-volume, continuous agentic workflows where frontier model pricing is a real constraint, and where execution efficiency matters as much as peak capability.
How to Run It Locally
Option 1: Ollama (Easiest One-Command)
# Install Ollama if you haven't already
# macOS:
brew install ollama
# Linux:
curl -fsSL https://ollama.ai/install.sh | sh
# Windows: Download from ollama.ai
# Run Nemotron 3.5 Lightning — downloads and starts automatically
ollama run nemotron-3.5-lightning
# You'll see:
# pulling manifest
# pulling model: ████████████████ 100% [18.4 GB]
# >>> Send a message (or type /bye to exit)
# Test it immediately
>>> Write a Python function to parse a JSON log file and extract all ERROR messages
That’s it. One command. The model downloads and runs locally. Your data never leaves your machine.
Hardware requirements for Ollama:
- Minimum: 16GB RAM (will use CPU, slower)
- Recommended: 24GB RAM or GPU with 16GB VRAM
- Ideal: NVIDIA GPU with 24GB+ VRAM (RTX 3090/4090, RTX PRO series)
Option 2: Use the NVIDIA NIM API (No GPU Required)
If you don’t have local hardware, NVIDIA offers hosted inference via their NIM (NVIDIA Inference Microservices) API:
# pip install openai (NIM uses OpenAI-compatible API)
from openai import OpenAI
import os
# NVIDIA NIM uses OpenAI-compatible API format
client = OpenAI(
api_key=os.environ["NVIDIA_API_KEY"], # Get from build.nvidia.com
base_url="https://integrate.api.nvidia.com/v1"
)
def ask_nemotron(prompt: str, system: str = None) -> str:
"""Call Nemotron 3.5 Lightning via NVIDIA NIM API"""
messages = []
if system:
messages.append({"role": "system", "content": system})
messages.append({"role": "user", "content": prompt})
response = client.chat.completions.create(
model="nvidia/nemotron-3.5-lightning-30b-a3b",
messages=messages,
max_tokens=2000,
temperature=0.1 # Low temperature for coding/analysis tasks
)
return response.choices[0].message.content
# Test it
result = ask_nemotron(
prompt="Analyse this stack trace and identify the root cause:nn"
"java.lang.OutOfMemoryError: Java heap spacen"
"tat java.util.Arrays.copyOf(Arrays.java:3512)n"
"tat com.example.TaskService.processBatch(TaskService.java:234)",
system="You are an expert software engineer. Be concise and specific."
)
print(result)
Option 3: Hugging Face Transformers (Full Control)
# pip install transformers torch accelerate
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
# Load model and tokenizer
model_name = "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B"
print("Loading tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(model_name)
print("Loading model... (this will take a few minutes)")
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.bfloat16, # BF16 for efficiency
device_map="auto" # Automatically distribute across GPUs
)
def generate(prompt: str, max_new_tokens: int = 500) -> str:
"""Generate text with Nemotron 3.5 Lightning"""
# Format as chat
messages = [{"role": "user", "content": prompt}]
# Apply chat template
formatted = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True
)
# Tokenize
inputs = tokenizer(
formatted,
return_tensors="pt"
).to(model.device)
# Generate
with torch.no_grad():
outputs = model.generate(
**inputs,
max_new_tokens=max_new_tokens,
temperature=0.1,
do_sample=True,
pad_token_id=tokenizer.eos_token_id
)
# Decode only the new tokens
new_tokens = outputs[0][inputs["input_ids"].shape[1]:]
return tokenizer.decode(new_tokens, skip_special_tokens=True)
# Test
print(generate(
"Write a Python function to check if a file is a valid JSON and "
"return the parsed data or an appropriate error message."
))
Option 4: DGX Spark (NVIDIA’s Recommended Local Setup)
If you have a DGX Spark (NVIDIA’s personal AI supercomputer):
# Set environment variables
export MODEL_CKPT=nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4
export DSPARK_CKPT=nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4-DSpark
# Run with speculative decoding (fastest option on DGX Spark)
# DSpark drafter gives you additional speed through speculative decoding
docker run --gpus all
-e MODEL_CKPT=$MODEL_CKPT
-e DSPARK_CKPT=$DSPARK_CKPT
-p 8000:8000
nvcr.io/nvidia/nemotron:latest
The DSpark drafter is a smaller companion model that “drafts” multiple tokens at once, which the main model then verifies. This gives you higher throughput on local hardware where you are not running many parallel requests.
Building a Real Agentic System With Nemotron 3.5 Lightning
Here is a complete, working example of the system-of-models pattern, using Nemotron 3.5 Lightning for execution and routing complex decisions to a frontier model:
# smart_agent.py
# A coding agent that uses Nemotron 3.5 Lightning for execution
# and escalates complex decisions to a frontier model
from openai import OpenAI
import os
import json
import subprocess
import pathlib
# Nemotron 3.5 Lightning — execution layer
lightning_client = OpenAI(
api_key=os.environ["NVIDIA_API_KEY"],
base_url="https://integrate.api.nvidia.com/v1"
)
LIGHTNING_MODEL = "nvidia/nemotron-3.5-lightning-30b-a3b"
# Frontier model — planning and complex reasoning
# Could be Claude, GPT-5, or Nemotron 3 Ultra
frontier_client = OpenAI(
api_key=os.environ["OPENAI_API_KEY"]
)
FRONTIER_MODEL = "gpt-5.5-turbo"
def classify_task_complexity(task: str) -> str:
"""
Quickly classify whether a task needs a frontier model or Lightning.
Returns: "simple" | "complex"
"""
# Use Lightning to classify — even this meta-task is a simple execution job
response = lightning_client.chat.completions.create(
model=LIGHTNING_MODEL,
messages=[
{
"role": "system",
"content": """Classify this coding task as SIMPLE or COMPLEX.
SIMPLE tasks (Lightning can handle):
- Reading files, listing directories
- Running commands and reading output
- Simple bug fixes (null check, off-by-one, typo)
- Writing boilerplate code (CRUD, config files)
- Parsing logs or structured data
- Writing or running tests for simple functions
COMPLEX tasks (needs frontier model):
- Architectural decisions affecting multiple systems
- Diagnosing subtle race conditions or performance issues
- Designing new APIs or data models
- Security vulnerability analysis and remediation
- Understanding and refactoring unfamiliar large codebases
- Novel algorithm design
Return ONLY: {"complexity": "simple"} or {"complexity": "complex"}"""
},
{"role": "user", "content": f"Classify: {task}"}
],
max_tokens=20,
temperature=0.0
)
try:
result = json.loads(response.choices[0].message.content)
return result.get("complexity", "complex") # Default to complex if unclear
except Exception:
return "complex" # Safe default
def execute_with_lightning(task: str, context: str = "") -> str:
"""Handle simple execution tasks with Nemotron 3.5 Lightning"""
print(f" Lightning: {task[:60]}...")
response = lightning_client.chat.completions.create(
model=LIGHTNING_MODEL,
messages=[
{
"role": "system",
"content": """You are a precise coding execution agent.
Complete the task directly and concisely.
Return code in ```language``` blocks.
For commands, prefix with $ in a code block.
Be specific. No preamble."""
},
{
"role": "user",
"content": f"{task}nnContext:n{context}" if context else task
}
],
max_tokens=1000,
temperature=0.1
)
return response.choices[0].message.content
def reason_with_frontier(task: str, context: str = "") -> str:
"""Handle complex reasoning tasks with frontier model"""
print(f" Frontier: {task[:60]}...")
response = frontier_client.chat.completions.create(
model=FRONTIER_MODEL,
messages=[
{
"role": "system",
"content": """You are a senior software architect.
Reason carefully about complex technical problems.
Explain your reasoning. Consider edge cases and alternatives."""
},
{
"role": "user",
"content": f"{task}nnContext:n{context}" if context else task
}
],
max_tokens=2000,
temperature=0.3
)
return response.choices[0].message.content
def smart_agent(goal: str, codebase_path: str = ".") -> None:
"""
Intelligent coding agent that routes tasks to the right model.
Uses Nemotron 3.5 Lightning for high-volume execution steps.
Uses frontier model only for complex reasoning.
"""
print(f"n{'='*60}")
print(f"SMART AGENT: {goal}")
print(f"{'='*60}n")
# Track token usage by model
lightning_calls = 0
frontier_calls = 0
# Step 1: Plan the approach (complex — use frontier)
print("Planning approach...")
plan = reason_with_frontier(
task=f"""Create a step-by-step plan to: {goal}
List 5-8 concrete steps. Be specific about what files to check,
what commands to run, and what to look for.
Format as numbered list.""",
context=f"Working in directory: {codebase_path}"
)
frontier_calls += 1
print(f"nPlan:n{plan}n")
# Step 2: Execute the steps
# Parse the plan into individual steps
steps = [
line.strip()
for line in plan.split('n')
if line.strip() and line.strip()[0].isdigit()
]
results = []
for i, step in enumerate(steps, 1):
print(f"n--- Step {i}: {step[:50]}... ---")
# Classify this step
complexity = classify_task_complexity(step)
lightning_calls += 1 # Classification used Lightning
if complexity == "simple":
# Use Lightning for execution
result = execute_with_lightning(
task=step,
context=f"Goal: {goal}nPrevious results: {json.dumps(results[-2:])}"
)
lightning_calls += 1
else:
# Use frontier for complex reasoning
result = reason_with_frontier(
task=step,
context=f"Goal: {goal}nPrevious results: {json.dumps(results[-2:])}"
)
frontier_calls += 1
results.append({"step": step, "result": result[:200]})
print(f"Result: {result[:200]}...")
# Step 3: Synthesise the final answer (complex — use frontier)
print("n--- Synthesising results ---")
summary = reason_with_frontier(
task=f"Summarise what was accomplished to: {goal}",
context=f"Steps completed: {json.dumps(results)}"
)
frontier_calls += 1
print(f"n{'='*60}")
print("RESULT:")
print(f"{'='*60}")
print(summary)
# Show efficiency metrics
total_calls = lightning_calls + frontier_calls
print(f"n{'='*60}")
print(f"EFFICIENCY METRICS:")
print(f" Total model calls: {total_calls}")
print(f" Lightning calls: {lightning_calls} ({lightning_calls/total_calls*100:.0f}%)")
print(f" Frontier calls: {frontier_calls} ({frontier_calls/total_calls*100:.0f}%)")
print(f" Estimated cost reduction vs all-frontier: ~{lightning_calls/total_calls*100:.0f}%")
print(f"{'='*60}")
# Run it
smart_agent(
goal="Debug the failing authentication tests in this project",
codebase_path="."
)
# Example output:
# SMART AGENT: Debug the failing authentication tests in this project
#
# Planning approach...
# Frontier: Create a step-by-step plan to: Debug the failing...
#
# Plan:
# 1. List all test files in the authentication module
# 2. Read the failing test output from the last CI run
# 3. Identify the specific test cases that are failing
# 4. Read the authentication middleware source code
# 5. Diagnose the root cause of the failures
# 6. Implement the fix
# 7. Run the tests to verify the fix
#
# --- Step 1: List all test files... ---
# Lightning: List all test files in the authentication module
#
# --- Step 5: Diagnose the root cause... ---
# Frontier: Diagnose the root cause of the failures
#
# EFFICIENCY METRICS:
# Total model calls: 11
# Lightning calls: 8 (73%)
# Frontier calls: 3 (27%)
# Estimated cost reduction vs all-frontier: ~73%
This is the real-world pattern. 73% of calls go to Lightning (fast, cheap). 27% go to the frontier model (expensive, necessary). The task quality is equivalent to using the frontier model throughout. The cost is a fraction.
Fine-Tuning Nemotron 3.5 Lightning for Your Domain
One of the biggest advantages of an open model is the ability to fine-tune it for your specific domain. NVIDIA provides the training recipes alongside the weights.
# Fine-tuning with NVIDIA NeMo framework
# pip install nemo_toolkit['all']
from nemo.collections.llm import MistralConfig7B, MegatronT5Config
from nemo.collections.llm.recipes import nemotron
# Example: Fine-tune for cybersecurity agent tasks
# (Like CrowdStrike's production deployment)
fine_tune_config = {
"model": "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B",
"dataset": {
"train": "your_domain_data/train.jsonl",
"validation": "your_domain_data/val.jsonl"
},
"training": {
"max_steps": 1000,
"learning_rate": 2e-5,
"batch_size": 4,
"gradient_accumulation_steps": 8
},
"peft": {
"method": "lora", # LoRA fine-tuning — efficient, lower memory
"rank": 32,
"alpha": 64,
"target_modules": ["q_proj", "v_proj"]
}
}
# Training data format for agent fine-tuning
training_example = {
"messages": [
{
"role": "system",
"content": "You are a cybersecurity threat analysis agent."
},
{
"role": "user",
"content": "Analyse this network log for suspicious patterns:n[log content]"
},
{
"role": "assistant",
"content": "THREAT ANALYSIS:nSeverity: HIGHn..."
# Your domain-specific expected output
}
]
}
CrowdStrike’s deployment demonstrates that fine-tuned Lightning can achieve frontier-level accuracy for domain-specific tasks, at Lightning’s cost and speed.
When to Use Nemotron 3.5 Lightning And When Not To
Use Nemotron 3.5 Lightning when:
Your workload is primarily agent execution tool calls, file operations, output validation, structured data processing. This is where the 30% speed advantage and MoE efficiency matter most.
You need high-volume, continuous inference. Always-on agents, real-time monitoring, processing thousands of events per hour. Frontier model pricing at this volume is economically impractical.
Privacy and local deployment matter. Open weights means you can run entirely on your own infrastructure. Your data never leaves your network.
You want to fine-tune for a specific domain. The open training recipes mean you can customise Lightning for cybersecurity, legal, medical, or any other vertical and achieve better accuracy for your domain than a general frontier model.
You have local hardware from RTX GPUs to DGX Spark and want to maximise its utilisation.
Use a frontier model instead when:
You need peak reasoning capability for genuinely novel, complex problems. Architectural decisions for large systems. Novel algorithm design. Security research on unknown vulnerabilities.
You are running low task volume where speed and cost are not constraints.
Your task is primarily planning and orchestration rather than execution.
Use both together when:
You are building production agent systems, which is most of the time. Lightning for execution, frontier for planning. NeMo Switchyard for routing between them.
The Bigger Signal: Efficiency Is the New Scale
For the past three years, the AI race was about one number: parameter count. Bigger models won. More compute won. The labs with the most GPU time won.
Nemotron 3.5 Lightning signals that this race is changing.
A model that scores 51.56% on SWE-bench, matching some frontier models, while using only 3B active parameters per token is not just efficient. It is a proof of concept for a different kind of competition.
The competition is no longer just: who can build the most intelligent model?
It is also: who can deliver the most intelligence per dollar of compute?
Who can run frontier-quality intelligence on local hardware?
Who can scale agentic workloads to millions of tasks per day without the cost curve making it economically impossible?
Nemotron 3.5 Lightning positions NVIDIA not just as the company that builds the GPUs everyone trains on, but as a company shipping competitive open models, routing libraries, and inference infrastructure for the production AI era.
The next three years of AI development will be won as much by efficiency as by capability. Nemotron 3.5 Lightning is a bet on that thesis, placed in public, with open weights.
The question for every developer and architect reading this is the same one Nemotron raises implicitly: are you still routing every task to the most expensive model available, or have you started thinking about which tasks actually need it?
Everything You Need to Start Today
# ── OLLAMA (EASIEST) ──────────────────────────────────────────
brew install ollama # macOS
curl -fsSL https://ollama.ai/install.sh | sh # Linux
ollama run nemotron-3.5-lightning # Download and run
# ── NVIDIA NIM API ────────────────────────────────────────────
# Get API key at: build.nvidia.com
# pip install openai
# Model name: nvidia/nemotron-3.5-lightning-30b-a3b
# Base URL: https://integrate.api.nvidia.com/v1
# Uses OpenAI-compatible API format
# ── HUGGING FACE ──────────────────────────────────────────────
# Model: nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B
# NVFP4 (quantized, faster): nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4
# pip install transformers torch accelerate
# ── DGX SPARK ────────────────────────────────────────────────
export MODEL_CKPT=nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4
export DSPARK_CKPT=nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4-DSpark
# ── KEY NUMBERS ───────────────────────────────────────────────
# Total parameters: 30B
# Active per token: 3B
# Context window: 1M tokens
# SWE-bench Verified: 51.56%
# PinchBench: 85.37%
# Speed: up to 4x similar-sized models
# License: OpenMDW-1.1 (commercial use OK)
# Training data cutoff: May 2026
# ── NEMO SWITCHYARD ──────────────────────────────────────────
# pip install nemo-switchyard
# Routes agent steps to Lightning vs frontier models automatically
# GitHub: github.com/NVIDIA/NeMo-Switchyard
# ── FINE-TUNING ───────────────────────────────────────────────
# pip install nemo_toolkit
# Weights, data, and recipes all open under OpenMDW-1.1
References
[1] NVIDIA Technical Blog. NVIDIA Nemotron 3.5 Lightning Delivers Fast, Accurate Specialized Task Execution for Long-Running Agents. August 11, 2026. https://developer.nvidia.com/blog/nvidia-nemotron-3-5-lightning-delivers-fast-accurate-specialized-task-execution-for-long-running-agents/
[2] NVIDIA Blog. NVIDIA Nemotron 3.5 Lightning and NeMo Switchyard Deliver Faster, Smarter, More Efficient Agentic AI. August 11, 2026. https://blogs.nvidia.com/blog/nemotron-lightning-switchyard-rtx-dgx/
[3] DataCamp. Nemotron 3.5 Lightning: Features and Benchmarks. August 2026. https://www.datacamp.com/blog/nemotron-3-5-lightning
[4] Artificial Analysis. NVIDIA launches Nemotron 3.5 Lightning. August 2026. https://artificialanalysis.ai/articles/nemotron-3-5-lightning-launch
[5] Hugging Face. nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4. https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4
[6] NVIDIA NIM API Reference. nemotron-3.5-lightning-30b-a3b. https://docs.api.nvidia.com/nim/reference/nvidia-nemotron-3-5-lightning-30b-a3b