X-VLA: the 0.9B cross-embodiment vision-language-action model, as a per-call API

X-VLA is a small vision-language-action model for robot arms from Tsinghua's AIR institute, the Shanghai AI Laboratory, and Peking University. It is about 0.9 billion parameters, in a field where the big names run 3 to 7 billion. And it was built to cross robot bodies from day one: one backbone, many arms, a small learned prompt per arm, not full retraining. This page is the platform's written record for a metered per-call action lane for it: the row sits in the platform's model data, and it is not on the public list.

Last verified: 2026-10-05

What it is

The paper is "X-VLA: Soft-Prompted Transformer as Scalable Cross-Embodiment Vision-Language-Action Model", a preprint from October 2025, later accepted at ICLR 2026 (the paper; the acceptance is announced in the code repository). The version people run is X-VLA-0.9B, packaged on the Hub as lerobot/xvla-base.

A 0.9B model in two parts

Two halves, one small package; the table above carries the parts. Only the main view goes through the full encoder. Extra views, like a wrist camera, go through the vision part alone. Actions come out through flow matching: the model pulls a noisy placeholder path onto a clean one. Continuous motion, one pass, not one token at a time.

Soft prompts, explained

This is the idea behind the name. Every robot setup differs: arms, cameras, data habits. Most models pour all that data into one net and hope it blends. X-VLA instead gives each data source a small set of learned numbers, a soft prompt. The prompt rides in with the images and text. It tells the shared backbone which body it is driving.

The payoff shows up when a new robot arrives: freeze the backbone, train only a new prompt plus light head layers. The paper says this route tunes about 9 million numbers, one percent of the model, close to models that tune billions, with about 300 times fewer trainable numbers. Body-specific knowledge lives in the tiny prompt; general skill stays in the backbone.

The cross-body story

Phase one used the 290K episodes in the table above; phase two adapts to a target domain with the prompt route. The authors claim state of the art across the sweep, their claim, and the benchmarks below show each number with its date.

The real-robot work is the part no directory page sums up. The team collected the open Soft-Fold dataset themselves, about one and a half minutes per demo. The project page carries a 120-minute uncut video of the arms folding nonstop. For a 0.9B model, that is the surprise.

Use cases

• Fast control loops. A small model answers fast. A 7B model needs a serious card and patience. This class runs on modest hardware and leaves budget for cameras and the arm itself.
• Many arms, one brain. The prompt route means the fifth robot you add costs a prompt, not a new model. Labs with a shelf of different arms get one serving path.
• Cheap tuning experiments. Training one percent of the model makes an experiment an afternoon, not a cluster booking. Test whether your data is good before you spend on scale.
• Soft-object work. The Soft-Fold line shows the class handling cloth, the hardest common case in handling tasks.
• Edge and mobile builds. Under 2 GB of weights at half precision fits Jetson-class boards and small work cells where a 7B model does not.

Where it is the wrong tool: precise assembly to the millimeter, heavy contact tasks, and scenes far from its training mix. The bigger models carry more: pi05 with its DROID and LIBERO tunes, OpenVLA-OFT, or MolmoAct2. For the fastest small policy on one task, ACT still wins. SmolVLA is the other sub-1B option.

VLABench, the benchmark the authors ship

VLABench is a language-guided handling suite with long task sequences, built at Fudan University. It pushes past single-step picking, where small models usually collapse. The X-VLA authors ship a tuned checkpoint for it, with scoring code public; the number sits in the table below. The LIBERO test guide explains how the standard suites are scored and why setups differ.

X-VLA versus OpenVLA and the field

No comparison page on the open web covers X-VLA today. The versus results are generic pages that never mention it. The honest short version sits in the benchmarks below, from the paper's own LIBERO table, every row tuned for those suites. Treat it as one lab's table, not a verdict. The class gap is real: X-VLA works at 0.9B, an eighth of OpenVLA's size. Serving cost: the local versus API break-even guide. Power: the Jetson versus cloud guide.

API usage

The lane's contract speaks the platform's action route, POST /v1/action, with a Bearer key from the console. Multipart form data in, JSON out. The model id is x-vla-0.9b. The tabs below are the contract the lane ships under.

A served request returns three things. actions is the chunk in the model's own shape and length; the LeRobot default here is 32 steps. normalization is the stats block the endpoint applied, untouched. usage is ours: call count and cost on every answer. Metering is per call: one served request is one billed call, a refused request bills nothing, the prepaid wallet is the stop, under the 25 MiB body cap.

This model suits per-call serving, and the authors' own reference code agrees. One HTTP server holds the model; each robot POSTs observations as JSON and gets actions back. A hosted lane is that pattern, server owned for you. A robot arm is idle most of the minute; a per-call lane charges at the moment of action. At 0.9 billion parameters, each moment stays cheap. Every field, error code, and limit is in the run-action reference.

curl

curl -X POST "https://api.ironstratum.com/v1/action" \
  -H "Authorization: Bearer $KEY" \
  -F "model=x-vla-0.9b" \
  -F "instruction=fold the towel and place it in the basket" \
  -F 'state=[0.0, 0.12, -0.4, 0.0, 0.5, 0.1, 0.0]' \
  -F "image=@main.jpg" \
  -F "image=@wrist.jpg"

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/action",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    data={
        "model": "x-vla-0.9b",
        "instruction": "fold the towel and place it in the basket",
        "state": "[0.0, 0.12, -0.4, 0.0, 0.5, 0.1, 0.0]",
    },
    files=[
        ("image", ("main.jpg", open("main.jpg", "rb"), "image/jpeg")),
        ("image", ("wrist.jpg", open("wrist.jpg", "rb"), "image/jpeg")),
    ],
    timeout=30,
)
resp.raise_for_status()

answer = resp.json()
chunk = answer["actions"]         # the action chunk, in the model's own shape
stats = answer["normalization"]   # the stats this endpoint applied
print("steps in this chunk:", len(chunk))
print("cost of this call:", answer["usage"].get("cost"))

lerobot

import os
import requests
from lerobot.cameras.opencv import OpenCVCamera

session = requests.Session()
session.headers["Authorization"] = "Bearer " + os.environ["KEY"]

cam = OpenCVCamera(camera_index=0, fps=30, width=640, height=480)
cam.connect()

instruction = "fold the towel and place it in the basket"
state = [0.0] * 7  # your arm's joint positions, same order on every call

running = True
while running:
    frame = cam.async_read()
    resp = session.post(
        "https://api.ironstratum.com/v1/action",
        data={
            "model": "x-vla-0.9b",
            "instruction": instruction,
            "state": "[" + ", ".join(str(s) for s in state) + "]",
        },
        files={"image": ("main.jpg", frame, "image/jpeg")},
        timeout=30,
    )
    resp.raise_for_status()

    chunk = resp.json()["actions"]
    for step in chunk:
        state, running = arm_step(state, step)  # your arm driver goes here
        if not running:
            break

The loop is the sync form; async runs the current chunk while the next frames send. The local path stays open next to the lane: install lerobot with the xvla extra, load the policy class. Same model, same per-body stats contract.

Norm stats and the embodiment question

Every X-VLA checkpoint carries the stats of its tuning data: the LIBERO, WidowX, and folding editions differ. Use the stats that ship with the checkpoint you run, or the arm will barely move. The normalization stats guide walks the failure class; the robot embodiment stats doc page covers the per-body contract. Here the answer carries the normalization block it applied, byte for byte.

Benchmarks

Every number below carries its source, its date, and its evidence class. The paper's numbers: version posted October 11, 2025, later accepted at ICLR 2026. The LeRobot numbers: vendor packaging docs, read 2026-10-05. Nothing here is this platform's own measurement; the lane does not serve.

LIBERO, simulation, the number this site's family pages cite. The LeRobot checkpoint lerobot/xvla-libero claims 93 percent success on the LIBERO suites (LeRobot X-VLA docs, read 2026-10-05). That is the same number the VLA category page and the LIBERO test guide carry for this model. It is an average. No per-suite breakdown is published for that artifact.

LIBERO, the authors' full fine-tune. The paper's table reports 98.1 average, with 98.2 spatial, 98.6 object, 97.8 goal, and 97.6 long. The light route, tuning 9 million numbers, reports 93 on the same suites in the paper's opening section. The repo's LoRA rows, read October 5, 2026, land between: 96.2 spatial, 96.0 object, 94.4 goal, 83.2 long. The authors also note that moving their checkpoints to the Hub format costs around one percent on some datasets. Three artifacts, three owners, one honest story. The light route gives up roughly five points against the full tune and costs one percent of the training.

Across the other suites, from the paper's table (October 2025).

Context from the same table. On LIBERO averages: OpenVLA 7B at 76.5, OpenVLA-OFT at 97.1, pi0 3B at 94.1, GR00T N1 3B at 93.9, the 2B SmolVLA at 88.8, MemoryVLA 7B at 96.7. One table, one setup. Every row was tuned for those suites by the X-VLA team. Independent cross-testing of this model barely exists yet. The leaderboard sites list it, but no third-party page tests it against peers on shared real robots. This section takes this platform's measured numbers, dated, under the platform's name, only once they exist. Treat every claim above as the authors' or the packagers'. It is.

Getting started

1. Read the primaries. The paper. The project page. The LeRobot docs. The model card. Every identity fact on this page traces to those four.
2. Tune before you trust it near hardware. The card says it plainly: a base model to tune on your use case. Record your own episodes. Train the prompt route. Test with the arm at low power. The SO-101 cloud brain guide walks the full record, train, and serve loop where this fits.
3. Write your client against the contract now. The tabs above are the shape the lane ships under. The run-action reference documents every field, limit, and error. 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. The loaded balance is the spend bound. Each key revokes alone.

Related pages in this family: the VLA category page explains the model class. SmolVLA and ACT share the small-model tier, MolmoAct2 covers the SO-100 cohort, and sam2.1-large and cosmos-reason2-2b join the robot lanes. The models index lists the platform's current offering.