molmo2-er: Molmo2-ER, the Molmo 2 embodied-reasoning vision-language model, documented as a metered API

molmo2-er is this platform's name for a metered lane that serves Molmo2-ER, the embodied-reasoning vision-language model from the Allen Institute for AI. The model is real, public, and open weight today. On this platform the molmo2-er 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. No other host serves this model. Live checks on October 5, 2026 found zero hosted APIs for the ER variant anywhere, and this platform's lane is the only one since. This page explains what ER means. It shows how the variant differs from the Molmo 2 family. It reports the benchmark record with its owner named. It covers what running the weights yourself takes. And it gives the exact call contract the lane serves.

Last verified: 2026-10-06

What it is

Molmo2-ER is a 4 billion parameter vision-language model. It reads images and video and writes text. Per the official model card, ER stands for Embodied Reasoning. The model is built for the perception skills that downstream action models depend on. The card names them: scene understanding, pixel-accurate pointing, multi-image and egocentric-exocentric correspondence, and video temporal reasoning. The model is built on Molmo 2, which pairs a Qwen3-4B language backbone with a SigLIP2 vision encoder. It serves as the vision-language backbone of MolmoAct2, Ai2's open robot action model.

In plain words: this is the model a robot stack uses for its eyes. Point at the red valve. Say which shelf the part came from. Match what the wrist camera sees with what the room camera sees. Say whether the object moved since the last frame. Those are embodied perception questions. They need answers that carry pixels and timestamps, not just words.

The identity facts, each with its owner:

The name map: Molmo2-ER, Molmo 2-ER, MolmoER

One model, three renderings. Search results mix them freely:

All three name the same model. The paper also states the relationship in its own words. MolmoAct2 introduces a VLM backbone tuned for spatial and embodied reasoning, trained on a 3.3M-sample corpus with a specialize-then-rehearse recipe. That sentence is the ER variant, described from the action model's side.

The family split matters just as much. Molmo 2 shipped in December 2025 as a set of general models: Molmo2-4B, Molmo2-8B, and Molmo2-O-7B. They answer questions about images and video for anyone. Molmo2-ER arrived five months later, in May 2026, with a narrower job. It starts from the released 4B checkpoint and trains further for embodied perception. The distinction is the training, not the size. ER shares its 4B backbone with the base family model. What differs is what it was tuned to see.

The training recipe, from the card's table, in plain terms. Stage one is specialization: 20,000 steps over a 3.3 million sample embodied corpus. The named sources include SAT, RoboPoint, RefSpatial, VST-P, VSI-590K, SIMS-VSI, RoboVQA, SenseNova-SI, CLEVR, and GRiD-3D, plus a slice of general Tulu-3 data. Stage two is rehearsal: 1,500 steps that mix embodied data with general Molmo 2 data at full 16,384 sequence length. The point of stage two is that the focused skills land without erasing the general ones. Specialize, then rehearse. That order is why the model can point precisely and still answer an ordinary question about a photo.

The posture on this platform, stated plainly: the row is on the public list with its rate set, the id serves, confirmed by the October 6, 2026 request, and the rate renders on the pricing page. The models index is the live catalog. The chat category page lists the platform's chat models, this row among them.

Use cases

The skill list defines the jobs. Each skill below comes from the card's own definition of the model.

• Robot perception front-end. The card names the downstream user: action models. Send camera frames, get pointing, scene descriptions, and spatial answers. The MolmoAct2 connection below is the shipped example of this pattern.
• Pixel-accurate pointing and grounding. Ask which object, get coordinates. Pointing is a first-class output skill, not a prompt trick. It is the skill the whole Molmo 2 line was built around.
• Multi-image and egocentric-exocentric correspondence. Match what a wrist camera sees against what a room camera sees. Two views of one scene, one answer. That is a robot-specific need, and general chat models handle it poorly.
• Video temporal reasoning. Did the object move. What happened first. The model reads video and reasons about time inside it.
• Spatial question answering over images and video. Left or right, nearer or farther, how many. The benchmark suite the card reports on is built from exactly these tasks.
• Labeling embodied data. A model that points and answers spatial questions can also label. It can mark objects in frames and write spatial captions for datasets that will train the next model.

The MolmoAct2 connection

The Ai2 blog states the relationship in one sentence worth keeping exact. MolmoAct 2 does not simply start from Molmo 2. It starts from Molmo 2-ER, a specialized embodied-reasoning variant. The action model keeps this model as its vision-language backbone. It then adds a dedicated action expert that generates robot actions through flow matching. The two connect through a per-layer KV-cache bridge. The action side also carries its own embodiment data: per-robot statistics, stored as norm stats files, that turn model output into joint positions for a specific arm.

For a builder, the split is the useful part. You can run the full action model and get robot poses out. Or you can run the perception model alone and feed your own controller, your own planner, or a different action model. The perception model is the reusable piece, and it is the piece this page's lane serves. The action-model pages in this family include the MolmoAct2 lane and the Cosmos-Reason2 reasoning lane. The cosmos-reason2-2b page covers the reasoning sibling, and each row has its own page.

Run the weights yourself, or call the hosted lane

The weights are Apache-2.0 and ungated. Self-hosting is a real option, and the hosted lane above is the other one.

Run the weights yourself when the data must stay inside your boundary, or when you want to fine-tune the perception skills on your own scenes. Know the lift going in. The artifact is float32 and 19.4 GB. A bfloat16 build halves that class. The repository uses custom model code, so serving stacks need the trust-remote-code flag. The molmo2 repository documents the supported path: vLLM at version 0.15.0 or newer, with a Gradio demo script and a molmo-utils package that prepares images and video for the model's processor. The vLLM supported-models table lists the Molmo 2 family under its architecture class. One published guide, read October 5, 2026, serves the 4B family sibling with an 8K window at 60 percent memory use. It reports short text answers in about half a second and short video answers in about seven. That guide is third-party evidence about the family, not a measurement of the ER variant. This page labels it that way.

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. It returns each call's cost with the call. Spending stops when the balance is gone. The served window is published below as a row fact, and the lane serves today.

One local-path caution the community keeps relearning: Ai2 ships no GGUF build for this family. The one-command local tools that depend on GGUF do not carry it. Third-party quants exist for the 4B base model. For the ER variant, the vLLM path above is the documented one.

API usage

The designed contract is the platform's chat route. It is POST /v1/chat/completions, authorized by a Bearer key from the console, OpenAI-compatible in shape. The model id is molmo2-er.

The served context window for the row is 8,192 tokens. The model's native window is 16,384. The row's enforced window is the number to plan against. A listed chat row publishes its enforced window here. That is the platform's rule: the window a lane actually enforces is the window the page states.

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 the usage object. 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.

curl

curl -X POST "https://api.ironstratum.com/v1/chat/completions" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "molmo2-er",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "Point at the leftmost valve and describe what is behind it."},
          {"type": "image_url", "image_url": {"url": "data:image/png;base64,<frame bytes>"}}
        ]
      }
    ],
    "max_tokens": 512
  }'

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/chat/completions",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "molmo2-er",
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Did the red box move between these two frames? Answer yes or no, then say where it is in each."},
                    {"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": 1024,
    },
    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="molmo2-er",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the scene and list every object you can point at, left to right."},
                {"type": "image_url", "image_url": {"url": "data:image/png;base64,<frame bytes>"}},
            ],
        }
    ],
    max_tokens=1024,
)

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

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

Benchmarks

Three evidence layers, each labeled. None of them is this platform's own measurement. This platform's own measurements are not on this page; every number below carries its named owner. The platform's rule is that a number publishes only after it is measured and held. The benchmark refresh for this lane is later work, not a promise on this page.

The publisher's card. The official model card reports, read 2026-10-05, that the model outscores every open-weight baseline and the strongest closed-source models on 9 of 13 established embodied reasoning benchmarks. The peers it names are Gemini Robot-ER 1.5 Thinking and GPT-5. The overall average is 63.8 percent, a 17 point gain over the Molmo 2 starting point. The named suites:

Publisher-run, publisher-named suite, publisher-chosen peers. That label stays on the numbers.

The May 2026 launch blog. The MolmoAct2 post carries the second rendering. Across 13 embodied-reasoning benchmarks covering pointing, multi-image reasoning, ego-exo correspondence, and video spatial reasoning, Molmo 2-ER scores an average of 63.8 out of 100. The blog names the peers it beats: GPT-5, Gemini 2.5 Pro, Qwen3-VL-8B, and GR-ER 1.5. Same publisher, same suite, an independent page repeating the headline with the peer names. It is still the publisher measuring its own model.

What nobody has. No independent benchmark of this variant exists. The independent analytics sites carry no page for it. The general family models do have third-party coverage, and even there the numbers are thin. One major analytics page showed no serving data at all on the October 5, 2026 read, because nobody was serving the family through a measured path either. So the honest read is this: a strong publisher claim, a named suite, a dated record, and no independent check yet. If a workload matters, run it on your own tasks before committing, on this lane or any other.

Getting started

1. Read the primary sources. The model card, the molmo2 repository, and the MolmoAct2 paper are all public. Every identity fact on this page traces to one of them.
2. Prototype on the open weights. Apache-2.0 and ungated mean the vLLM path is open today. The hardware section above carries the memory math and the trust-remote-code requirement.
3. Check the rate and the index. The pricing page renders this row's rate card, and the models index is the live catalog.
4. 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.