This is not a frontier model and NVIDIA is not pretending it is. It is something more useful to most teams shipping agents right now: the fastest open-weight model in its size class, priced at a level where you can stop rationing calls.

Below is the full technical picture. Architecture, the benchmark tables from NVIDIA's own harness and from independent evaluators, the throughput numbers, what early adopters measured in production, where the model genuinely loses, and the arithmetic on when routing to it actually pays.

TL;DR

• What it is: a 30B-total, 3B-active hybrid Mixture-of-Experts model with interleaved Mamba-2, MoE and attention layers, distilled from Nemotron 3 Ultra, released under the permissive OpenMDW-1.1 license.

• Speed: Artificial Analysis measured median output speeds of nearly 670 tokens per second on a pre-release endpoint serving the final NVFP4 weights. Time per Intelligence Index task lands near 0.5 minutes, against roughly 3.5 minutes for Qwen3.6 35B A3B, 3.4 minutes for gpt-oss-120b, 5.8 minutes for Gemma 4 31B and 7.3 minutes for Qwen3.6 27B.

• Intelligence: 24 on the Artificial Analysis Intelligence Index, a +9 point jump over Nemotron 3 Nano, level with gpt-oss-120b and just behind Nemotron 3 Super at 26, a model roughly four times its size.

• Agentic gains: Terminal-Bench v2.1 at 24% versus 7% for Nemotron 3 Nano, and a GDPval-AA v2 Elo of 824 that surpasses both Nemotron 3 Super and gpt-oss-120b.

• Context: 1M tokens, text-only, with a runtime reasoning toggle.

• Qubrid pricing: $0.069 / $0.29 / $0.0069 per million input / output / implicit-cache tokens. Roughly 46x cheaper per agent step than a frontier open model on a typical tool-calling shape. Math below.

• Honest caveat: on raw reasoning and repo-scale coding it trails Qwen3.6 35B A3B by a wide margin. This is a workhorse, not an orchestrator.

What is NVIDIA Nemotron 3.5 Lightning?

Nemotron 3.5 Lightning is an open 30B mixture-of-experts model with 3B active parameters, built for the execution layer of always-on agents, and designed for harnesses like OpenClaw and Hermes Agent.

The framing matters more than the parameter count. NVIDIA's argument, laid out in the launch technical blog, is that long-running AI agents spend most of their time on high-volume execution: tool calls, result validation, and subagent delegation, and using a frontier reasoning model for every execution step adds cost and latency. The proposed shape is a system of models, where frontier reasoning models such as Nemotron 3 Ultra handle orchestration and complex planning while smaller, more efficient models handle the high-volume execution layer.

That is a real observation about production agent workloads. If you have instrumented a Deep Agents or OpenHands-style loop, you already know that the overwhelming majority of model calls are not hard. They are "did this tool call succeed", "extract the three fields from this JSON", "summarise this 40-line diff", "is this alert worth escalating". Those calls do not need a frontier model. They need to be fast and they need to be cheap, because there are hundreds of thousands of them.

Nemotron 3.5 Lightning is engineered specifically for that regime. NVIDIA released it alongside NeMo Switchyard, an open source routing library, which tells you exactly how the company expects it to be deployed: as the cheap leg of a two-model system.

Architecture: why Nemotron 3.5 Lightning is fast

The speed story is not one trick. It is four, stacked.

1. Hybrid Mamba-2 + MoE + attention

Per the Hugging Face model card, the model employs a hybrid Mixture-of-Experts architecture, utilizing interleaved Mamba-2 and MoE layers, along with select Attention layers.

Two independent efficiency wins are being combined here.

The MoE win is on compute per token. A router sends each token to just a few of its many experts, so only a fraction of the model's parameters run per token, providing the capacity of a larger dense model at the compute cost of a small one. 3B active out of 30B total means each forward pass costs roughly what a 3B dense model costs, while the model retains the knowledge capacity associated with 30B of stored weights.

The Mamba-2 win is on memory per token of context. Standard attention carries a KV cache that grows linearly with sequence length, so decode speed degrades as context fills. State-space layers carry a fixed-size recurrent state instead. In a long-running agent, where context accumulates across dozens of turns of tool output, this is the difference between a loop that stays fast at turn 40 and one that crawls. It is also what makes the 1M context window practically claimable rather than theoretical.

The full precision card lists context length up to 1M tokens, with 256K used for single H100 deployment, and single-GPU deployment on 1x H100 80GB or 1x A100 80GB.

2. Multi-token prediction baked into pretraining

Most speculative decoding is bolted on after the fact. Here it is trained in. Nemotron 3.5 Lightning underwent a dedicated pretraining stage to bake multi-token prediction into the model, as with Nemotron 3 Super and Ultra, and after training, a dedicated MTP-boosting phase further improved MTP accuracy.

The model card describes this as an explicit training stage: a continued pre-training phase in which MTP heads learn to predict multiple future tokens, providing richer training signals to the base model and aligning the MTP layers with the base model's distribution.

This detail is the single most underrated part of the release, and the independent testing backs it up. More on that in the Thoughtworks findings below.

3. Two shipped draft models

Beyond MTP, NVIDIA published two separate drafters:

• DSpark, described on the model card as a semi-autoregressive speculative-decoding drafter that proposes a whole block of candidate tokens in a single forward pass from a parallel backbone, recommended for DGX Spark and low-concurrency data centre deployments. The method is documented in an accompanying paper.

• DFlash, a speculative-decoding drafter that uses a lightweight block-diffusion model to generate an entire draft block in one forward pass.

NVIDIA's guidance on when each wins is workload-shaped: MTP is best suited for medium to high concurrency, with the optimal draft length decreasing as concurrency increases. That is the expected behaviour. As batch size rises, the GPU is already saturated with real tokens and speculative draft tokens have less idle capacity to exploit.

4. NVFP4 as a first-class checkpoint

Nemotron 3.5 Lightning ships with an NVFP4 checkpoint alongside BF16, using the same specialized NVFP4 kernels that power Nemotron 3 Ultra across NVIDIA Blackwell, Hopper and Ampere GPUs.

Critically, the quantization is near-lossless. Artificial Analysis reported that they measured the NVFP4 variant at 24 on the Intelligence Index and saw minimal degradation compared to the higher-precision weights. This is because the model was pretrained in that numerical regime rather than crushed into it afterwards: the pre-training phase used an NVFP4 recipe.

The practical consequence is that the fast checkpoint and the accurate checkpoint are the same checkpoint. You are not trading intelligence for throughput.

Training pipeline, in brief

From the model card: the model was pre-trained with over 20T tokens, followed by continued pre-training for MTP, supervised fine-tuning on synthetic code, math, science, tool calling, instruction following and structured output data, and then multi-environment reinforcement learning using GRPO across math, code, science, instruction following, multi-step tool use, multi-turn conversations and structured output environments, using an asynchronous RL architecture that decouples training from inference and leverages MTP to accelerate rollout generation.

Data freshness is worth noting for anyone building knowledge-sensitive agents: the pre-training data has a cutoff date of September 2025 and the post-training data has a cutoff of May 2026.

Nemotron 3.5 Lightning benchmarks

Two sets of numbers matter here, and they tell slightly different stories. Both are worth reading.

NVIDIA's harness-consistent evaluation

NVIDIA published the following table on the model card, with the caveat that accuracy numbers were measured by NVIDIA under a consistent harness (NeMo Gym / NeMo Evaluator SDK) and may differ from vendors' self-reported numbers. Reproduction recipes are published in NeMo Gym.

Source: NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16 model card

Read this table honestly. Nemotron 3.5 Lightning wins one row outright against its nearest same-class rival. Qwen3.6 35B A3B takes MMLU Pro, GPQA Diamond, SWE-bench Verified, SWE-bench Multilingual, Terminal-Bench, PinchBench, BrowseComp, GDPval and AA-LCR. On SWE-bench Verified the gap is 51.56 against 70.12, which is not close.

What Lightning does do is beat its own predecessor decisively on the agentic rows: 85.37 against 66.11 on PinchBench, 24.58 against 8.29 on Terminal-Bench 2.1, 832 against 473 on GDPval-AA-V2. And it takes IFBench outright at 71.88, above every model in the table except Gemma 4 26B. Instruction adherence is disproportionately important in agent loops, because a model that silently deviates from an output contract breaks the parser downstream.

The correct reading is that this is not the most capable model in its class. It is the most capable model in its class at this speed and price point, which is a different and more commercially relevant claim.

Independent evaluation: Artificial Analysis

Artificial Analysis evaluated the model at launch and reached a compatible conclusion from a different direction.

Nemotron 3.5 Lightning scores 24 on the Artificial Analysis Intelligence Index, a +9 point improvement over Nemotron 3 Nano at 15, putting it in line with gpt-oss-120b at 24 and only just behind Nemotron 3 Super at 26, a model roughly four times its size.

They are explicit about where it does not lead: Nemotron 3.5 Lightning sits behind the most intelligent small models in its size class such as Qwen3.6 35B A3B at 32 and Muse Glimmer (high) at 35, but it is built for a different point on the frontier.

And they are explicit about what that different point is: in pre-release testing serving the final NVFP4 weights, median output speeds of nearly 670 tokens per second, much faster than those models are served in the market today.

Their agentic read is the same as NVIDIA's: its GDPval-AA v2 Elo of 824 surpasses both Nemotron 3 Super and gpt-oss-120b, while its Terminal-Bench v2.1 score of 24% is more than three times Nemotron 3 Nano's 7% and almost matches gpt-oss-120b.

The Decoder summarised the positioning bluntly, noting that at 669 tokens per second Lightning is the fastest model in the comparison, and that despite generating a similar number of tokens per task as its predecessor Nemotron 3 Nano, it delivers much better results.

Two footnotes on the parameter count, since you will see both numbers cited. NVIDIA's model card states 30B total and 3B active. Artificial Analysis measures 31.6B total and 3.6B active parameters. The difference is embedding parameters, which NVIDIA has historically excluded from the headline figure across the Nemotron 3 family.

The metric that actually matters: time per task

Raw tokens per second is a vanity number if the model is verbose. The useful figure is wall-clock time to finish a unit of work.

Across the Artificial Analysis Intelligence Index, Nemotron 3.5 Lightning's Time per Intelligence Index Task is approximately 0.5 minutes, substantially faster than open weights peers: well ahead of Qwen3.6 35B A3B at roughly 3.5 minutes, gpt-oss-120b at roughly 3.4 minutes, Gemma 4 31B at roughly 5.8 minutes and Qwen3.6 27B at roughly 7.3 minutes.

This time per task is driven by extremely high output speeds along with solid token efficiency, with Lightning using a similar number of output tokens per task to Nemotron 3 Nano while delivering its +9 point Intelligence Index gain.

Seven times faster to task completion than the model that beats it on nine benchmark rows is the entire commercial argument for this release. If your agent runs 200,000 steps a day, a 7x reduction in per-step latency is not a nicety. It is the difference between a workload that finishes overnight and one that does not.

NVIDIA frames the same result at the batch level: on PinchBench, Nemotron 3.5 Lightning reaches 86% accuracy while completing 10,000 tasks 30% faster than Qwen3.6 35B at similar accuracy.

What people are actually finding

Vendor benchmarks are a starting point. Here is what independent and early-access teams published within the first 24 hours.

Thoughtworks: the built-in speculative decoder is unusually good

Thoughtworks ran early-access testing and published their findings alongside three technical reports. Their speculative decoding result is the most technically interesting thing published about this model so far.

Across 2,091 measurements spanning two inference engines, two GPU generations (H200 and B200), three workloads and concurrency from 1 to 128, the native multi-token prediction head delivered 1.46 to 1.96 times the throughput of unaccelerated decoding, with task accuracy shown equivalent.

The kicker: they trained a state-of-the-art EAGLE-3 draft head specifically for this model, which required engineering work to extend open tooling to support its hybrid Mamba-2 architecture, and it could only match the built-in head overall. A native head this strong is rare; usually a purpose-trained drafter wins comfortably.

They translated that into unit economics on self-hosted hardware: on self-hosted hardware, cost per token is the reciprocal of throughput, so the built-in acceleration roughly halves GPU cost per generated token under load, decreasing from $0.477 to $0.250 per million output tokens in their worked example. The full speculative decoding report has the methodology.

Their domain adaptation results are equally relevant if you are considering fine-tuning. They trained legal and healthcare low-rank adapters concurrently on a single node with eight H100 80GB GPUs in a few hours. The legal adapter was preferred in 112 of 163 blind comparisons, a 75% win rate at p < 0.001, and on CaseHOLD accuracy more than doubled from 35% to 77%. The healthcare adapter was preferred in 82 of 167 blind comparisons, a 60% win rate at p = 0.002. The legal adapter held every general-capability check, including reasoning, mathematics and broad legal knowledge, to within 1.5 points of the base model.

That last clause is the important one. Domain adaptation that does not induce catastrophic forgetting elsewhere is the hard part, and their evidence says the base model tolerates it well.

CodeRabbit: a production router for under $100

CodeRabbit post-trained Lightning to handle the routing decision at the front of every code review, which they describe as one of their highest-volume model calls.

Post-training was remarkably easy, requiring under three hours of experimentation and costing less than $100. The post-trained model achieved higher accuracy than the previous GPT-class model by about 4% and reduced estimated inference costs by about 50%.

The measured progression on a frozen 1,000-task evaluation:

Source: CodeRabbit engineering blog

Two details worth respecting. First, they were disciplined about their own claims: the paired confidence interval for the route delta crossed zero, so they treat that route result as non-regression rather than a statistically decisive improvement, with the output-agreement gain being the clearer RLVR result. Second, the token efficiency: the tuned model also generated 63.4% fewer output tokens than the baseline model on this task.

LangChain: 7% of calls needed a frontier model

LangChain benchmarked routing using their internal Deep Agents evaluation suite and asked the most useful question anyone has asked about this release: how many of an agent's calls actually need a frontier model?

The answer was 7%. A 30B parameter model handled the other 93%. Routing between NVIDIA Nemotron 3.5 Lightning and Claude Opus 4.8 cut the total cost by 74% against running Opus alone, while retaining 93% of its accuracy for the same calls.

NVIDIA's Switchyard technical blog describes the suite: 145 multi-turn agentic tasks reflecting production workloads such as customer support dialogue under policy constraints, on-call incident investigation, and multi-step workflow automation across messaging, issue tracking and email, evaluating tool use, multi-step retrieval, filesystem operations and long-context summarization, with scenarios drawn from t2-bench airline, Berkeley Function Calling Leaderboard, FRAMES and Nexus.

LangChain's framing of the trade is the most actionable line in the whole launch cycle: routing is a trade, 74% cheaper for about six points of accuracy reduction. Run the cost tradeoff formula before you build anything: judge cost divided by the price gap gives the offload you need. If your two models are close in price, that number climbs past 100% and routing cannot pay unless you host the cheap model yourself.

Other reported figures from the same launch: Ramp used NeMo Switchyard to match a frontier model's performance while cutting costs by 58% and runtime by 33% in Ramp SWE-Bench, and per VentureBeat, Cognition integrated Switchyard's staged router into Devin Desktop for internal use and reported near-frontier performance on FrontierCode Main while cutting mean cost 28% relative to routing everything to a single frontier model.

The healthy skepticism

Not everyone is taking the headline numbers at face value, and the pushback is worth reading before you build a deployment plan.

Ryan Shrout of Signal65 made the sharpest structural point: if quadrupling token generation only buys 30% at the task level, most of the wall clock in an agentic workload is going somewhere other than generating tokens, which is an argument for orchestration mattering more than raw model speed.

He is right, and it is the most useful caveat on the release. Tool execution, network round trips, retrieval and harness overhead dominate a lot of agent loops. A 4x faster model does not make a 900ms API call return sooner. His broader warning: benchmark outcomes vary quite a bit depending on which suite you run, how it is configured and who ran it, and NVIDIA labels the headline routing cost chart as internal benchmarks, so claims like these need independent vetting.

On Hacker News, the early developer read was similar in tone: the model looks behind the Qwen equivalent on most benchmarks, with the interest coming from what it does at its size and speed rather than from leaderboard position.

Our position at Qubrid: both things are true. The benchmark deficit against Qwen3.6 35B A3B is real and you should not pretend otherwise. The throughput and price advantage is also real, independently measured, and for high-volume execution work it is the variable that determines whether the workload is economically viable at all. Benchmark against your own eval set before you commit either way.

Nemotron 3.5 Lightning pricing on Qubrid AI

That is a 20% discount off list, applied across all three lines, with no commitment, no reserved capacity and no minimum spend. Pay-as-you-go from a $5 deposit.

What that means per agent step

Prices per million tokens are hard to reason about. Prices per unit of work are not. Take a realistic tool-calling step: 8,000 input tokens (system prompt, tool schemas, accumulated conversation, last tool result) and 800 output tokens (a short reasoning trace plus a tool call).

On this shape, Nemotron 3.5 Lightning is roughly 29x cheaper per step than Qwen3.8-Max and roughly 46x cheaper per step than Kimi K3.

Run that out to a real workload. An always-on agent fleet executing one million steps a month costs $784 on Lightning. The same fleet costs about $22,950 on Qwen3.8-Max and about $36,000 on Kimi K3. That gap is what LangChain's 74% routing result looks like from the invoice side, and it is why the cost-tradeoff formula they published almost always resolves in favour of routing when the price gap is this wide.

Implicit caching changes the arithmetic again

Agent loops are pathologically repetitive at the front of the prompt. The system prompt does not change. The tool schemas do not change. The first twenty turns of an eighty-turn session do not change. All of it gets resent on every call.

Qubrid's implicit cache prices those repeated prefix tokens at $0.0069 per million, which is 10x cheaper than fresh input. Take the same 8,000-token step and assume 6,000 tokens are a stable prefix that hits cache:

That is a 47% reduction on an unchanged workload, purely from prompt discipline. You get it by keeping your system prompt and tool definitions byte-identical across requests and appending new content at the end rather than interleaving it. No configuration required.

Nemotron 3.5 Lightning API: how to run it

The Qubrid endpoint is OpenAI-compatible. If you have an existing OpenAI SDK integration, this is a base URL change and a model ID change.

Base URL: https://platform.qubrid.com/v1 Endpoint: POST /chat/completions Model ID: nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4

Get a key at platform.qubrid.com/api-keys.

Note the NVFP4 suffix. Qubrid serves the NVFP4 checkpoint, which is the one NVIDIA recommends for production inference and the one every throughput number in this post was measured on. Artificial Analysis ran their 670 tokens per second measurement and their Intelligence Index score of 24 against the final NVFP4 weights, so the published benchmarks describe the checkpoint you are actually calling. The BF16 release exists for a different job: NVIDIA describes it as the reference weights intended primarily for customization rather than direct production inference.

cURL

curl https://platform.qubrid.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $QUBRID_API_KEY" \
  -d '{
    "model": "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4",
    "messages": [
      {"role": "user", "content": "Summarize this stack trace and name the likely root cause."}
    ],
    "max_tokens": 4096,
    "temperature": 0.6,
    "top_p": 1
  }'

The model ID is case-sensitive. Casing variants will return an error.

Python

# pip install openai
from openai import OpenAI

client = OpenAI(
    base_url="https://platform.qubrid.com/v1",
    api_key="QUBRID_API_KEY",
)

stream = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4",
    messages=[
        {"role": "user", "content": "Explain speculative decoding in two sentences."}
    ],
    max_tokens=4096,
    temperature=0.6,
    top_p=1,
    stream=True,
    extra_body={"enable_thinking": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Node / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://platform.qubrid.com/v1",
  apiKey: process.env.QUBRID_API_KEY,
});

const response = await client.chat.completions.create({
  model: "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4",
  messages: [
    { role: "user", content: "Classify this support ticket: billing, technical, or account." }
  ],
  max_tokens: 512,
  temperature: 0.6,
  top_p: 1,
});

console.log(response.choices[0].message.content);

Sampling settings

The examples above use temperature 0.6 and top_p 1, which is the configuration in the Qubrid docs for this endpoint and a sensible default for agent work where you want stable, parseable output.

It is worth knowing that NVIDIA's model card recommends different values for the raw weights: temperature 1.0 and top_p 0.95. That is not a contradiction so much as a difference in objective. NVIDIA is tuning for the model's best general-purpose behaviour; agent pipelines usually want tighter, more repeatable output, and lower temperature with unrestricted top_p gets you there.

The practical advice is the same either way: pick one, hold it constant across your eval runs, and do not clamp temperature to 0.1 out of reflex. Reasoning models trained with RL tend to degrade rather than stabilise when you squeeze them that hard.

Reasoning on and off

Lightning has a configurable reasoning mode. On the Qubrid API you control it with enable_thinking inside extra_body, and it is the single highest-leverage knob for cost control on this model.

# Reasoning OFF for high-volume classification, extraction, and validation
response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4",
    messages=[{"role": "user", "content": "Is this log line an error? Answer yes or no."}],
    max_tokens=16,
    temperature=0.6,
    top_p=1,
    extra_body={"enable_thinking": False},
)

The economics here are worth spelling out, because output tokens cost roughly four times what input tokens cost. A reasoning trace on a call whose entire useful output is the word "yes" can easily be 300 tokens of thinking wrapped around 1 token of answer. At $0.29 per million output tokens that is $0.000087 wasted per call, which sounds like nothing until you multiply it by a million calls a month and find you have spent $87 for the model to deliberate about log lines.

Turn reasoning off for anything mechanical: classification, field extraction, format validation, boolean checks, routing tags. Leave it on for multi-step tool decisions where the model genuinely has to weigh options. Both modes are trained behaviours, not prompt hacks, so neither one is a degraded version of the other.

Tool calling

Tool calling is the primary use case for this model.

tools = [{
    "type": "function",
    "function": {
        "name": "search_incidents",
        "description": "Search the incident database by service and severity",
        "parameters": {
            "type": "object",
            "properties": {
                "service": {"type": "string"},
                "severity": {"type": "string", "enum": ["p1", "p2", "p3"]},
            },
            "required": ["service"],
        },
    },
}]

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4",
    messages=[{"role": "user", "content": "Any P1s open on checkout-api?"}],
    tools=tools,
    max_tokens=4096,
    temperature=0.6,
    top_p=1,
)

print(response.choices[0].message.tool_calls)

One footnote for anyone building a coding agent specifically: NVIDIA's model card flags that these workloads should set force_nonempty_content, because some coding harnesses break when the model returns a tool call with an empty content field. Check the Qubrid docs for the exact parameter form on this endpoint before you wire it in.

Agent harnesses and IDEs

Because the endpoint implements the Chat Completions spec exactly, anything that accepts a custom base URL works without modification. That includes Hermes Agent, OpenClaw, Cline, Kilo Code, OpenCode, OpenHands, Cursor, Zed, Open WebUI and Dify. Qubrid has step-by-step integration guides in the docs, and we published a full walkthrough for running Hermes Agent against the Qubrid API that applies unchanged here.

NVIDIA explicitly trained the model for these harnesses. Per the technical blog, harness-optimized training means the model is trained for popular agent harnesses, enabling agents to make more accurate calls while reducing latency for high-volume tasks. That is not marketing language. It shows up in the IFBench and PinchBench numbers.

Where Nemotron 3.5 Lightning fits: the two-model pattern

The deployment pattern NVIDIA is proposing, and the one the LangChain and CodeRabbit results validate, is straightforward:

Planner tier. A frontier model decomposes the task, decides strategy, handles the genuinely hard reasoning, and reviews final output. Low call volume, high value per call. On Qubrid, this is where Kimi K3 or Qwen3.8-Max sit.

Execution tier. Nemotron 3.5 Lightning runs the loop. Tool invocation, result parsing and validation, format normalisation, retry logic, classification, extraction, summarisation of tool output, subagent delegation. High call volume, low value per call, hard latency budget.

The workloads NVIDIA and its partners have publicly targeted map cleanly onto this: CrowdStrike for cybersecurity, Harvey with Trajectory for legal services, CodeRabbit for code review, Lila Sciences for agentic tasks across physical and life sciences, and Fastino Labs for software development, finance and healthcare workloads. Ollama's model page lists the same shapes: personal agents managing email, calendar, projects and bookings; financial services workflows extracting data from documents, checking policy rules and monitoring risk signals; cybersecurity operations enriching alerts, classifying incidents and querying logs; and telecom agents triaging network alarms.

Every one of those is a high-frequency, narrow-scope, structured-output task. That is the shape this model was built for.

Since you asked, yes, you can wire the routing yourself. NVIDIA's NeMo Switchyard is open source and provider-agnostic. Per NVIDIA, it provides a provider-agnostic SDK, supports both tuning-free and tunable routing algorithms, and maintains separation between routing logic and specific model providers, allowing flexible integration and adaptation as model deployments change. Because Qubrid exposes both tiers behind one OpenAI-compatible key, you can point both legs of the router at the same base URL and change only the model string.

Why run Nemotron 3.5 Lightning on Qubrid AI

One key, both tiers. The routing pattern above only works cleanly if the cheap model and the expensive model live behind the same integration. On Qubrid, Nemotron 3.5 Lightning, Kimi K3, Qwen3.8-Max, GLM-5.2, MiniMax M3, the Qwen3-Coder series and forty-plus other open models share one API key, one base URL and one billing surface. Switching a routing tier is a string change, not an integration project.

A graduation path when the volume justifies it. Token pricing is the right answer until it is not. Once an always-on agent fleet is running steady, high-utilisation traffic, dedicated GPUs are cheaper than per-token billing. Because Qubrid is a full-stack platform, that transition happens on the same platform: serverless inference to dedicated GPU instances to bare metal and on-premise appliances, without re-platforming.

Fine-tuning where the model already lives. The Thoughtworks and CodeRabbit results both point the same direction: this model's real value is unlocked by post-training it on your domain, and the cost of doing so is measured in hours and dollars rather than weeks and thousands. Qubrid supports fine-tuning and RAG on the same platform as inference, so the adapted model deploys where the base model already runs.

Transparent pricing. $0.069 in, $0.29 out, $0.0069 cached. Published, flat across the context window, 20% off list, no commitment tiers to negotiate.

When not to use Nemotron 3.5 Lightning

A model recommendation without a negative case is a sales pitch. Here is where this model is the wrong choice.

• Repository-scale software engineering. SWE-bench Verified at 51.56 against Qwen3.6 35B A3B's 70.12 is a decisive gap. Route hard bug-fixing and multi-file refactors up the stack.

• Hard reasoning and research. HLE at 11.72 and GPQA Diamond at 75.44 put it behind the frontier by a distance. It is not a research assistant.

• Deep factual recall. AA-Omniscience at 17.50 is below several models in its own comparison set. Ground it with retrieval rather than trusting parametric knowledge.

• Multimodal work. Text only. Artificial Analysis lists it as a text-only reasoning model. If you need vision, use a multimodal model.

• Languages outside its trained set. The card lists English and coding languages as primary, with Spanish, French, German, Italian and Japanese also supported. Beyond that, validate carefully.

• Workloads where model latency is not the bottleneck. Signal65's point stands. If your agent spends 80% of its wall clock waiting on tool APIs, a 4x faster model buys you very little. Instrument before you optimise.

Frequently asked questions

What is NVIDIA Nemotron 3.5 Lightning? It is an open-weight 30B-total, 3B-active hybrid Mixture-of-Experts language model released by NVIDIA on August 11, 2026, built for the high-volume execution layer of long-running AI agents. It uses interleaved Mamba-2, MoE and attention layers, is distilled from Nemotron 3 Ultra, and is licensed under OpenMDW-1.1 for commercial use.

What is the Nemotron 3.5 Lightning API pricing on Qubrid AI? $0.069 per million input tokens, $0.29 per million output tokens and $0.0069 per million implicit-cache tokens. That is 20% off list pricing of $0.0862, $0.36 and $0.0086 respectively, flat across the context window, pay-as-you-go with no minimum commitment.

How fast is Nemotron 3.5 Lightning? Artificial Analysis measured median output speeds of nearly 670 tokens per second in pre-release testing with the final NVFP4 weights. Time per Intelligence Index task is approximately 0.5 minutes, against roughly 3.5 minutes for Qwen3.6 35B A3B and 3.4 minutes for gpt-oss-120b. NVIDIA states up to 4x output speed of similar-sized models.

How does Nemotron 3.5 Lightning benchmark against Qwen3.6 35B A3B? Qwen3.6 35B A3B is more accurate on most rows, including MMLU Pro (85.63 vs 81.94), GPQA Diamond (83.40 vs 75.44), SWE-bench Verified (70.12 vs 51.56) and Terminal-Bench 2.1 (44.38 vs 24.58). Lightning wins IFBench (71.88 vs 63.71) and completes tasks roughly seven times faster. It is the better choice for high-volume execution, not for hard reasoning.

What is the Nemotron 3.5 Lightning context window? 1,048,576 tokens, roughly one million, text-only. NVIDIA notes that for single H100 deployment they use 256K.

What is the model ID for Nemotron 3.5 Lightning on Qubrid? nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4, used with the base URL https://platform.qubrid.com/v1. The string is case-sensitive and must match exactly. Qubrid serves the NVFP4 checkpoint, which is the variant NVIDIA recommends for production inference and the one the published speed and intelligence benchmarks were measured against.

Is the Qubrid Nemotron 3.5 Lightning API OpenAI-compatible? Yes. Any OpenAI SDK, framework or tool that accepts a custom base URL works without modification, including Hermes Agent, OpenClaw, Cline, Cursor, OpenCode, OpenHands, Zed, Open WebUI and Dify.

Does Nemotron 3.5 Lightning support tool calling and structured output? Yes. It was post-trained with multi-step tool use, multi-turn conversation and structured output environments in its reinforcement learning stage, and NVIDIA describes the model as harness-optimized for popular agent frameworks.

Can I turn reasoning off? Yes. Pass extra_body={"enable_thinking": False} on the Qubrid API. Turning it off for mechanical, high-volume calls materially reduces output token spend, since output tokens cost roughly four times what input tokens cost.

Can I fine-tune Nemotron 3.5 Lightning? Yes, and it responds well. CodeRabbit post-trained it in under three hours for less than $100 and beat their previous GPT-class baseline by about 4% on route agreement. Thoughtworks trained legal and healthcare adapters in a few hours on a single eight-GPU node, with the legal adapter winning 75% of blind comparisons and more than doubling CaseHOLD accuracy from 35% to 77%.

What license is Nemotron 3.5 Lightning released under? OpenMDW-1.1. Open for commercial use without material restrictions, with weights, data and training recipes published.

Should I self-host or use the API? The model runs on a single H100 or A100 80GB, so self-hosting is realistic. The question is utilisation. At low or bursty volume, per-token pricing is cheaper than an idle GPU. At sustained high volume, dedicated hardware wins. Qubrid supports both, so you can start on the API and move to dedicated GPUs on the same platform when your numbers cross over.

Get started

Nemotron 3.5 Lightning is live on the Qubrid AI API now.

1. Create an account and grab a key at platform.qubrid.com/api-keys.

2. Change your base URL to https://platform.qubrid.com/v1 and your model string to nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4.

3. Point it at your own eval set before you trust anyone's benchmark table, including this one.

Browse the full model catalog at platform.qubrid.com/models, or read the integration guides in the Qubrid docs.