NVIDIA-Nemotron-3-Super-120B-A12B

Nemotron 3 Super 120B-A12B

120 billion parameters, twelve active. Mamba-2, mixture-of-experts, and attention — in one stack.

Three Mechanisms, One Model

The architecture is a hybrid in a stronger sense than most models that use the word.

Interleaved Mamba-2 and MoE layers, with select Attention layers. Each does something the others cannot, and each is placed where it costs least.

Mamba-2 carries sequence state through a recurrent update at constant cost — no key-value cache that grows with the input. That is what makes long inputs and high request volume affordable.

MoE layers provide capacity without paying for it on every token.

Select attention layers give exact retrieval where it matters. Recurrent state compresses; attention does not. Placing a few attention layers among many recurrent ones buys precision where the model needs to look something up rather than remember it approximately.

The result is 120 billion parameters of capacity at twelve billion parameters of compute per token — with the long-context cost profile of a recurrent model rather than a transformer.

LatentMoE: Routing in a Smaller Space

The architectural refinement NVIDIA name specifically.

Tokens are projected into a smaller latent dimension for expert routing and computation.

The stated benefit: improving accuracy per byte.

Read that phrasing carefully — per byte, not per parameter. It is a statement about the information density of the representation rather than about parameter efficiency. Routing decisions and expert computation happen on a compressed form, which reduces what moves through the expert layers without reducing what the model can express.

Trained at NVFP4, Not Quantised to It

The Super model is pre-trained using NVFP4 quantization — the first model in the Nemotron 3 family trained at this precision — to maximise compute efficiency.

The distinction matters. Most models are trained at full precision and quantised afterwards, which leaves the cost of that conversion undocumented: you get benchmark numbers from one configuration and weights from another.

Here the model learned at the precision it ships in. What was evaluated and what you download are the same thing.

Multi-Token Prediction

MTP layers for faster text generation and improved quality, and NVIDIA name this as a specific difference from the smaller model in the family.

Two benefits from one component: a speculative decoding path, and — per NVIDIA — better quality rather than merely faster output.

Trained on 25 Trillion Tokens

Post-training fine-tuned on synthetic code, math, science, tool calling, instruction following, structured outputs, and general knowledge — with data designed to support long-range retrieval and multi-document aggregation.

Note the two cutoffs. Pre-training knowledge ends in June 2025; post-training behaviour was shaped through February 2026. The model's world knowledge and its instruction-following conventions come from different points in time.

The Data and the Recipe Are Published

What separates this family from most open-weight releases.

Major portions of the pre-training corpus are released in a dedicated dataset collection.

Major portions of the fine-tuning corpus are released in a separate post-training collection.

The end-to-end training recipe is available in NVIDIA's developer repository.

Evaluation results can be replicated using the published evaluator SDK.

A technical report documents the datasets and synthetic data generation methods.

Why that combination is unusual. Open weights let you run and fine-tune a model. Open data and an open recipe let you audit what went into it and rebuild from the same foundation. For regulated work, for research, and for anyone whose organisation asks what a model was trained on, that is a different category of answer.

Specifications

Published precisions: BF16, FP8, and NVFP4 from NVIDIA directly, plus community AWQ and GGUF builds.

Context length is not stated in the sources consulted. Confirm it from the model configuration.

Capabilities

Reasoning Is a Flag

The model responds by first generating a reasoning trace and then concluding with a final response, and that behaviour is configured through a flag in the chat template.

Not a request parameter — a template argument. Which matters when self-hosting, and is handled for you through an API.

Enable it for multi-step analysis, code, and anything with a decision in it.

Leave it off for classification, routing, extraction, and formatting — deliberation adds latency and nothing else on work that has one correct answer.

Built for Collaborative Agents

NVIDIA's positioning is specific, and the example they give is instructive.

Optimised for collaborative agents and high-volume workloads such as IT ticket automation.

That example says a lot. Ticket automation is not a benchmark task — it is a real workload where the same operation runs constantly, the individual decisions are moderate, and cost and latency per call decide whether the design is viable at all. Twelve billion active parameters against 120 billion of capacity is exactly the shape that workload wants.

Also named: AI agent systems, chatbots, retrieval-augmented systems, complex instruction following, and long-context reasoning.

Using Nemotron 3 Super on DEVUP AI

Base URL: https://api.devupai.com/v1 · Model ID: nvidia/NVIDIA-Nemotron-3-Super-120B-A12B

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024,
)

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

Node.js

import DevupAI from "devupai";

const client = new DevupAI({
  apiKey: process.env.DEVUP_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    model: "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B",
    messages: [{ role: "user", content: "Hello world!" }],
    max_tokens: 1024,
  });

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

main();

cURL

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

A High-Volume Routing Pipeline

The workload NVIDIA name, configured for it.

import json

SCHEMA = {
    "type": "json_schema",
    "json_schema": {
        "name": "ticket_triage",
        "strict": True,
        "schema": {
            "type": "object",
            "properties": {
                "category": {
                    "type": "string",
                    "enum": ["access", "hardware", "network", "software", "billing", "other"],
                },
                "urgency": {"type": "string", "enum": ["low", "normal", "high", "critical"]},
                "affected_system": {"type": ["string", "null"]},
                "requires_human": {"type": "boolean"},
            },
            "required": ["category", "urgency", "affected_system", "requires_human"],
            "additionalProperties": False,
        },
    },
}


def triage(ticket: str) -> dict:
    """Classify a support ticket into a fixed schema."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B",
        messages=[
            {
                "role": "system",
                "content": (
                    "Triage the ticket. Use null for affected_system when the ticket does not "
                    "name one — never infer it. Set requires_human to true when the ticket needs "
                    "judgment rather than a standard remedy."
                ),
            },
            {"role": "user", "content": ticket},
        ],
        response_format=SCHEMA,
        max_tokens=512,
        temperature=0,
    )
    return json.loads(response.choices[0].message.content)

Three deliberate choices.

Reasoning stays off. Triage into a fixed taxonomy has one correct answer, and deliberation costs latency without improving it.

temperature=0 for the same reason. Variance on a classification task is noise you pay for.

A requires_human field. The most useful output of an automation pipeline is frequently the decision not to automate — and asking for it explicitly gets it.

Long-Document Analysis

Where the Mamba-2 layers earn their place, and where post-training was specifically targeted.

from pathlib import Path

documents = "\n\n---\n\n".join(
    f"### {path.name}\n{path.read_text(encoding='utf-8')}"
    for path in sorted(Path("reports").glob("*.txt"))
)

response = client.chat.completions.create(
    model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B",
    messages=[
        {
            "role": "system",
            "content": (
                "Aggregate findings across these documents. Where two sources report the same "
                "figure differently, show both with their source. Report nothing you cannot "
                "attribute to a specific document."
            ),
        },
        {"role": "user", "content": documents},
    ],
    max_tokens=16384,
)

Multi-document aggregation is a named post-training target, alongside long-range retrieval. That makes this particular task one the model was explicitly prepared for rather than one it happens to handle.

Requiring attribution per finding is what converts an aggregation into something checkable. A synthesised figure with no source behind it is indistinguishable from a correct one until someone needs to verify it.

Self-Hosting

Unusually well equipped, and the ecosystem support reflects NVIDIA's position.

Three official precisions. BF16 for maximum fidelity, FP8 for balance, NVFP4 for running on a single B200 or DGX Spark — which NVIDIA call out specifically.

Community builds cover AWQ 4-bit and GGUF at several quantisations.

The training recipe is published in NVIDIA's developer repository, which matters if you intend to continue training rather than only run inference.

Evaluation is reproducible through the published evaluator SDK — you can verify the numbers rather than trusting them.

Reading the suffix matters. Every official checkpoint carries a precision suffix, and a -Base variant exists that is pre-trained only and does not follow instructions.

Where It Fits

High-volume automation — ticket triage, classification, routing, extraction — where twelve billion active parameters against 120 billion of capacity is the right economics.

Collaborative agent systems, which NVIDIA name as the design target.

Long-context and multi-document work, where the Mamba-2 layers keep cost flat and post-training specifically targeted retrieval and aggregation.

Regulated and audited environments, where published training data and a reproducible recipe are the deciding property.

Self-hosted deployment at single-GPU scale through the NVFP4 build.

Continued training and specialisation, given the open recipe.

Not for vision. Text only.

Practical Notes

Turn reasoning off for classification, routing, and extraction.

Use temperature=0 where there is one correct answer.

Require attribution on multi-document work.

Confirm the context window from the model configuration.

Read the precision suffix when downloading weights — and check for -Base, which does not follow instructions.

Use the published evaluator SDK if you need to verify a claimed result rather than accept it.

Limitations

Text only. No image, audio, or video input, and no image generation.

Context length is not documented in the sources consulted. Verify before designing around a figure.

Twelve billion active parameters is the compute ceiling per token. This is an efficiency model, and capability is bounded accordingly.

120 billion parameters must be loaded even though twelve run per token — the saving is in speed, not in memory.

Two different knowledge cutoffs. World knowledge ends June 2025; instruction behaviour was shaped through February 2026.

Reasoning is a template flag, not a request parameter. Relevant when self-hosting.

A base variant exists with a nearly identical name that does not follow instructions.

Published data is "major portions", not the complete corpus. More transparency than most, and not total.

Reasoning traces are working notes. Treat the final response as the output and the trace as debugging material.