cosmos-reason2-2b: Cosmos Reason 2 2B, the NVIDIA physical-AI reasoning vision-language model, documented as a metered API

cosmos-reason2-2b is this platform's name for a metered chat lane that serves Cosmos Reason 2 2B, the small reasoning vision-language model from NVIDIA. The model is real and downloadable today. On this platform the cosmos-reason2-2b model id answers directly: an October 6, 2026 request returned a 200 response with a full usage block. It is listed in the models index and on the pricing page as of October 6, 2026. It is also the only host serving it: live checks on October 5, 2026 found no hosted API for it anywhere, and the free listing NVIDIA once ran no longer serves it. This page is the record.

Last verified: 2026-10-06

What it is

Cosmos Reason 2 2B is a 2 billion parameter vision-language model: images and video in, text out. Per the official documentation, it is built for physical AI and robotics. It uses prior knowledge, physics understanding, and common sense to reason about the real world. NVIDIA's words: a planning model to reason what steps an embodied agent might take next.

The model is post-trained from Qwen3-VL-2B-Instruct, an Apache-2.0 base. It keeps that architecture: a vision encoder in front of a 28-layer language tower, 16 attention heads, 2,048 hidden size. The launch blog, dated January 5, 2026, gives the recipe: physical common sense and embodied reasoning data, supervised fine-tuning, reinforcement learning.

In plain words: this is the half of a robot stack that looks and decides. Moving the arm is another model's job, and those lanes have their own pages.

The identity facts, each with its owner:

The name and version map

One model, several renderings: the repository writes Cosmos-Reason2-2B, prose writes Cosmos Reason 2 2B, and this platform's alias is the model id you would call.

The family map, because the ground moved in 2026:

The short version: the open artifacts stayed, the hosted surfaces moved to a new generation, and the repository banner says future work focuses on Cosmos 3. None of that breaks the 2B. It is a settled, downloadable model.

The id serves on this platform, confirmed by the October 6, 2026 request, and the row is on the public list. The models index is the live catalog. This page is the written record, next to molmo2-er, the other reasoning row of this pair.

What the license says

This section answers the question buyers actually ask, from the agreement text itself. The split first: repository code is Apache 2.0, weights are under the NVIDIA Open Model License, and the repository lists a license contact for custom terms.

The agreement opens with three quoted lines:

• "Models are commercially usable."
• "You are free to create and distribute Derivative Models."
• "NVIDIA does not claim ownership to any outputs generated using the Models or Derivative Models."

The grant is perpetual, worldwide, non-exclusive, no-charge, and royalty-free. It is revocable in named cases: litigation over the model, or stripped safety guardrails. Use must stay consistent with the Trustworthy AI terms the agreement links.

Two duties travel with redistribution, and the second one surprises teams:

• Distributing the model means giving recipients the agreement plus a notice file reading "Licensed by NVIDIA Corporation under the NVIDIA Open Model License".
• The agreement covers serving. Distribute a Cosmos model, offer a product or service that uses one, or use it or its outputs to train or improve another AI model, and you must show "Built on NVIDIA Cosmos" where users can see it. A website, a product page, or a blog post all count.

One carve-out helps hosts: the agreement grants no rights to NVIDIA trade names or marks. The only allowed use is describing where the model came from.

The gate matters too. The official 2B and 8B weights sit behind license acceptance on Hugging Face; the 32B card, the repository, the docs, and the community quantizations sit open. The GR00T license guide walks the same question for another robot family.

Use cases

The official family card names three jobs. Each rides on the structured outputs: points, boxes, trajectories, timestamps, not prose.

• Robot planning and reasoning. The card's own framing: act as the brain for deliberate decision-making in a robot vision-language-action stack. The model reads the scene, breaks a command into steps, and hands coordinates to the part that acts. The other action-model pages in the same family here, such as pi05, smolvla, act, and x-vla-0.9b, are the other half of that split. The vla action lane page covers that lane, and the vision-language-action models explained guide walks the full pattern.
• Video analytics agents. Point the model at recorded or live video and ask for root-cause answers. The launch blog names production users of this pattern: a workplace-safety program that analyzes robot camera footage, and a smart-cities video analytics deployment. The OCR support means it reads text inside frames, so gauges, signs, and labels become data.
• Data curation and annotation. The model writes detailed, time-stamped captions for video. Those captions are the raw material for training the next round of physical AI models. NVIDIA points to its own curation framework, powered by this model family, for filtering and annotating large sensor datasets.

Where it sits next to the perception lanes: this model reasons over what it sees. The machine vision lane models, such as sam2.1-base, sam2.1-large, and da3-small, answer narrower questions faster: mask this object, estimate that depth. A working stack often uses both. Embodiment statistics are their own topic on the robot-embodiment-stats reference page.

Memory, and 2B versus 8B

The honest answer has three layers, because the artifacts differ. Each number carries its owner.

The device reality anchors it. On the Jetson Orin Nano Super, the smallest board in NVIDIA's tutorial, only the 2B fits, at a 768-token window. The AGX boards serve the 2B at 8,192. The tested platforms are datacenter-class: H100, GB200, and Jetson AGX Thor, inference in BF16.

The decision rule: run the 2B when the device is small and the loop is fast. Run the 8B when memory allows and scores matter more. The publisher's table below shows the 8B ahead on every category total.

Run it locally, or call the hosted lane

The official path, from the repository: accept the license on Hugging Face, then pick a runtime. The model ships inside transformers 4.57.0 and newer. For serving, NVIDIA recommends vLLM 0.11.0 or newer: a qwen3 reasoning parser flag, model length between 8,192 and 16,384. First startup takes a few minutes for loading and graph compilation.

The community path, from the quantization card: GGUF files of the same weights, ungated, built for llama.cpp and compatible tools. One command downloads and serves the quantized model, vision encoder at F16. One more build exists: an edge hardware company's mixed-precision W4A16 version that fits the 2B onto the smallest Jetson board. In that company's words, it keeps virtually the same accuracy. That artifact is gated.

Run the weights yourself when the data must stay inside your boundary, or when you want to fine-tune on your own scenes. Know the lift: the official numbers say 24 GB of GPU memory for the tested paths, and the smallest devices need the quantized builds.

Own a call instead of a stack when you would rather not host. The lane's contract here meters per token against a prepaid wallet. Every response returns its own cost. Spending stops when the balance is gone. The served window is published below as a row fact, and the lane serves today.

API usage

The designed contract is the platform's chat route: POST /v1/chat/completions, a Bearer key from the console, OpenAI-compatible in shape. The model id is cosmos-reason2-2b.

The served context window for the row is 4,096 tokens. The model's native window is far larger, up to 256K input tokens. Need longer runs? Batch the frames or trim the clips.

Metering is the wallet law. Calls meter per token against a prepaid wallet, and the refusal lands at the door: past an empty balance, any new request is turned away with a named error before work begins, and refused requests bill nothing. Every response returns its own cost in usage. Pages like this one never type rates by hand: this row's rate card renders on the pricing page and in the facts strip above, machine-derived from the platform's model data.

The lane serves under this alias today, confirmed by the October 6, 2026 request. The tabs below are the working contract the lane ships under, testable now via the quickstart.

curl

curl -X POST "https://api.ironstratum.com/v1/chat/completions" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "cosmos-reason2-2b",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "List every object you can point at, left to right, with 2D bounding box coordinates for each."},
          {"type": "image_url", "image_url": {"url": "data:image/png;base64,<frame bytes>"}}
        ]
      }
    ],
    "max_tokens": 2048
  }'

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "cosmos-reason2-2b",
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Did the red box move between these two frames? Answer yes or no, then give its position in each frame."},
                    {"type": "image_url", "image_url": {"url": "data:image/png;base64," + frame_a}},
                    {"type": "image_url", "image_url": {"url": "data:image/png;base64," + frame_b}},
                ],
            }
        ],
        "max_tokens": 2048,
    },
    timeout=120,
)
resp.raise_for_status()

message = resp.json()["choices"][0]["message"]
print(message["content"])
print("cost of this call:", resp.json()["usage"].get("cost"))

openai-sdk

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="cosmos-reason2-2b",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the scene, then give the 3D point location of the closest obstacle."},
                {"type": "image_url", "image_url": {"url": "data:image/png;base64,<frame bytes>"}},
            ],
        }
    ],
    max_tokens=2048,
)

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

The route speaks the OpenAI chat-completions shape. Existing SDK code moves across in two lines: base URL and model id.

Benchmarks

One evidence layer exists today, labeled. This platform's own measurements are not on this page; every number below carries its named owner. Numbers publish only after they are measured and held. The benchmark refresh is later work, not a promise on this page.

The publisher's comparative table. The official family card, dated April 28, 2026, compares each Cosmos size against the matching Qwen3-VL base model. The 2B column, read against its own base:

The standout single row: on a driving collision judgment task, the 2B scored 74.33 against 36.33 for the base. On an embodied-reasoning suite, 58.03 against 48.85.

The honest rows, same table. On one spatial judgment task the base scored higher, 77.62 against 75.52. Two suites tied exactly. One video task went to the base by 0.2 points. The post-training helped most on physics-shaped and driving-shaped tasks. It moved little on general spatial judgments. This model earns its keep where physical reasoning is the job.

The leaderboard claims. The launch blog says the family tops the Physical AI Bench and Physical Reasoning leaderboards and calls the model the number one open model for visual understanding. That is the publisher describing its own results on boards it names. Treat it as direction, not a verdict.

Getting started

1. Read the primary sources. The official documentation, the code repository, the license agreement, and the official family card are all public. Every identity fact on this page traces to one of them.
2. Check the license against your product. The commercial-use confirmations and the Built on NVIDIA Cosmos duty are quoted above. If your legal team wants the source, the agreement is one page.
3. Run the weights if they fit, or call the lane. The official path needs a Hugging Face account and 24 GB of GPU memory for the tested builds. The quant path needs neither, at some accuracy cost. The memory section above carries both, and the hosted lane serves today.
4. Check the rate and the index. The pricing page renders this row's rate card, and the models index is the live catalog.
5. Open the console when you build. The signup flow opens the wallet, the keys, and the billing history. Each key revokes alone, and the loaded wallet balance is the spend bound.