Does anyone host a VLA API? The dated map of who serves vision-language-action models

Barely. As of 2026-10-27, the whole hosted VLA market fits in one paragraph. Two small specialists serve robot action policies through an API. Abstract Inc publishes a rate card and takes an open account. Robotic Inference lists 24 policies from 13 families and runs invite-only. Two first parties hold waitlists. Google keeps its true action model, Gemini Robotics 2, in private preview. Physical Intelligence onboards its API beta in batches. Beyond the two specialists, one robot API from a major platform is public and priced, Google's embodied reasoning model ER 2, and it answers in text, not motor commands. Every big general host serves none; the class-by-class census lives in the big-hosts guide. The model hub holds the weights and no providers. Inference markets carry no robot rows. The one GPU vendor portal that serves robot models serves only its own. As of 2026-10-27 this platform has no public listing for a VLA model id either. The models index is the live catalog, and the written record for the model family sits on the VLA page.

Last verified: 2026-10-27

What it is

A vision-language-action model, or VLA, is one neural network with three jobs. It reads camera images and an instruction such as "put the red cube in the bowl". It outputs the commands that move the robot, usually as a chunk of actions for the next fraction of a second. A hosted VLA API is that model on someone else's machine. Your code sends images, the instruction, and the robot's state. It gets the action chunk back over HTTP. The class is not exotic. A survey published in May 2025 counted more than 80 VLA models from the previous three years. The number you can call on a hosted API, counted on 2026-10-27, is a handful.

One split does most of the work on this page, because the search results blur it. There are two tiers of robot model. The reasoning tier reads a scene and answers in text: object coordinates, bounding boxes, step plans. The action tier, the actual VLA policies, reads the same scene and outputs motor commands at control rate. Google sells the reasoning tier openly and keeps its action model gated. That is the whole market in one sentence, and every row in this census carries a tier label.

The demand side shows the gap plainly. Google's suggestion box, read on 2026-10-27, completes "vla model" with a rich robot list: models robotics, architecture, huggingface, benchmark, explained. Ask the same box for "vla api" and it returns the string itself and nothing else. Ask for "hosted vla api" or "vla inference api" and it returns nothing at all. The box knows the models. It has no API to suggest, because mostly none exists. Worse, the networking sense of the letters owns the API-shaped space. The box completes "hosted vla" as "host vlan". Ask it for "vlan api" and you get a full networking list, from a network documentation tool to a networking gear maker. Astronomy takes the rest. The rank-five result on this query, in the 2026-10-25 capture, is a telescope page. The Very Large Array keeps its own pages about wind and atmospheric phase at its antennas. An informed reader might expect that. A buyer in a hurry will not.

The search engine's own summary needs a decode too, because it is what most questioners read first. The AI Overview in the 2026-10-25 capture answers this query with three options. One is Google's ER model. One is the OpenVLA self-host script. The third is "enterprise cloud platforms" from Azure and AWS that supposedly sell VLA inference per call. The first is true but is the reasoning tier. Option two is you doing the hosting. And the third fails every check. The line traces to a consulting report, and the report names no product. No Azure surface named "Robotics AI Platform" could be found in Microsoft's own catalog on 2026-10-27. AWS retired its robotics service, RoboMaker, after it failed to gain traction, per The Robot Report. That service ran robot simulation anyway, not policies. When a machine-written answer names cloud platforms, read their model catalogs, not the summary. The catalogs carry zero VLA rows.

Use cases

The reader who typed "hosted vla api" wants someone else's GPU to move an arm, billed per call, this month. Four real paths exist. Each has a door, and each door has a state, dated below.

The first path is the specialists, and they are the closest thing to the product this page is named for. Abstract Inc runs one API for robot models and bills per million tokens in and per million actions out, with a public rate card. Its homepage names five models, pi 0.5 and MolmoAct2 among them, running on its own machines. One caution from the same-day reads. The card moved during the day: the pi 0.5 row was missing from one read on 2026-10-27 and back on a fresh read the same day, while the homepage kept naming the model throughout. Read both surfaces and date them before you budget.

Robotic Inference serves the bigger list. Its public model list carried 24 policies from 13 families on 2026-10-27. The set includes GR00T N1.7, OpenVLA and its LIBERO fine-tunes, SmolVLA, X-VLA, and pi 0.5. Each row is marked running or sleeping. Each model publishes a machine-readable contract. It names which cameras, how the state is laid out, the units, the coordinate frames, the control mode, the gripper rules, and whether a zero action is safe. That contract idea is the most grown-up thing in this young market. The door is the limit: the site is invite-only while in beta, one use per invite email, and no rates are public. Either way, remember what a policy is: a checkpoint tuned for an embodiment. A fine-tune that aces one benchmark arm will not move yours without the matching statistics, and the embodiment stats guide covers that pairing.

The second path is the first-party waitlists, and both are worth a slot in your week because the models are the strongest. Google's action tier, Gemini Robotics 2, is real and published. Google's robotics family page calls it the company's most advanced VLA model, one that controls robots "from bi-arms to full humanoids". Its model card lists the output as actions. The status line says private preview, and the access line is a waitlist. No rate exists.

Physical Intelligence opened the Pi API beta on October 13, 2026. You apply, say what you want to build, upload your demonstrations, and their machines fine-tune and serve the model through a hosted endpoint. Onboarding runs in batches. No model ids and no prices are published. These two doors suit teams building a product around one strong model, not teams shopping a catalog this week. The beta's access steps are walked through in the waitlist guide.

The third path is the one public priced robot API from a major platform, used for what it actually is. Gemini Robotics ER 2 is open with a standard key. Google's robotics docs are the honest description of it. The model identifies objects and reasons about spatial relationships, and it returns structured text. When it orchestrates a task, it does so by calling robot functions you provide. It plans. Your policy moves. So the working pattern is a pair: ER 2 as the eyes and the planner, an open policy you serve as the hands. Its per-million-token rates double on January 1, 2027, per Google's own pricing page read 2026-10-27, and the line-by-line read of that card is the rate card guide. The reasoning tier, and the term embodied reasoning itself, get their own treatment in the ER era guide.

The fourth path is self-hosting, and it is what the search results already hand you. Every top result that is not Google's docs is a way to run a policy yourself. The OpenVLA repo ships a serving script. GPU clouds post walkthroughs. NVIDIA publishes vla0 research code, and the VLAgents project ships a policy server. LeRobot does remote inference: a policy server runs the checkpoint on a GPU machine, and a thin client runs on the robot computer. The open weights are the most demanded robot artifacts anywhere. Read from the hub on 2026-10-27: more than 160,000 downloads in 30 days for the base SmolVLA, more than 110,000 for OpenVLA-7B, and more than 65,000 for GR00T N1.7 3B. The open toolkits' serving patterns are covered in the hosted-ways-to-run guide and the model class itself in the VLA explainer.

On this platform's own posture, stated plainly with its date: as of 2026-10-27 no VLA model id is on the public list, and the class is not currently offered here. This page promises no date and no arrival. What is published instead is the capability record on the VLA page. It describes the lane's eight models and what each was trained on. The platform's action route contract is public too, written up in the action route guide. Any robot client can be written against that contract today. The models index is the live catalog.

API usage

Three calls matter on this page. The first checks a live catalog. Listing state is read, never guessed from a blog post or a waitlist. The second is the publisher's own policy-server pattern for the open weights, the working self-host path. The third is this platform's action route, a public contract that answers 404 for any VLA id until a listing exists.

curl

The catalog check is one request:

curl -sS "https://api.ironstratum.com/v1/models" \
  -H "Authorization: Bearer $KEY"

The answer is the live list of model ids this platform lists. As of 2026-10-27, no VLA model id is in it. That is the whole check. Repeat it later and you learn whether that changed, without depending on any page's date.

The action call itself, if a VLA id ever appears in that list, is a multipart POST. Its shape is fixed today:

curl -X POST "https://api.ironstratum.com/v1/action" \
  -H "Authorization: Bearer $KEY" \
  -F "model=<id exactly as the models index lists it>" \
  -F "instruction=put the red cube in the bowl" \
  -F 'state=[0.12, -0.80, 1.25, 0.40, -0.20, 0.90, 0.50]' \
  -F "image=@cam0.jpg" \
  -F "image=@cam1.jpg"

Sent today with any unlisted id, it answers 404 with the code model_not_found. That is the honest answer. It is exactly what the platform's own docs promise for ids that are not on the public list.

python

The working path this week runs an open policy on a GPU you control. The pattern below is the publisher's own, from the openpi project that ships the pi 0.5 class checkpoints, the family both specialists also serve. Start the policy server on the GPU machine, where it listens on port 8000. On the robot machine, speak to it:

from openpi_client import image_tools
from openpi_client import websocket_client_policy

# Server started with scripts/serve_policy.py from the openpi
# repository and a pi 0.5 class checkpoint. Listens on port 8000.
client = websocket_client_policy.WebsocketClientPolicy(
    host="gpu-box.local", port=8000
)

for step in range(num_steps):
    # Resize images on the robot side to cut bandwidth, and keep
    # them uint8. The publisher's docs use 224 pixels here.
    observation = {
        "observation/image": image_tools.convert_to_uint8(
            image_tools.resize_with_pad(img, 224, 224)
        ),
        "observation/wrist_image": image_tools.convert_to_uint8(
            image_tools.resize_with_pad(wrist_img, 224, 224)
        ),
        "observation/state": joint_positions,  # unnormalized; the
        # server applies the norm stats for the checkpoint
        "prompt": "pick up the green cube",
    }
    action_chunk = client.infer(observation)["actions"]
    for action in action_chunk:
        arm_step(action)             # your arm driver, one row per tick

This is the publisher's pattern, not a rewrite. Images, instruction, and state go in. A chunk of actions comes out, in the checkpoint's own units. The statistics that match a checkpoint to your arm are the quiet variable, and the normalization stats guide explains the pairing. If you would rather not write the loop at all, the LeRobot project ships the same idea as a product. It gives you a policy server command for the GPU side. The robot client keeps moving from an action buffer while the next chunk computes.

lerobot

Here is the same loop against this platform's action route, with a LeRobot camera class for the frames. Four form fields make the contract. The model id is a string you read from the models index:

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 = "pick up the green cube and drop it in the bowl"
state = [0.0] * 7  # your arm's joint positions, same order every call

running = True
while running:
    frame = cam.async_read()
    resp = session.post(
        "https://api.ironstratum.com/v1/action",
        data={
            "model": MODEL_ID,  # set from the models index listing
            "instruction": instruction,
            "state": "[" + ", ".join(str(s) for s in state) + "]",
        },
        files={"image": ("scene.jpg", frame, "image/jpeg")},
        timeout=5,
    )
    resp.raise_for_status()

    for deltas in resp.json()["actions"]:
        state, running = arm_step(state, deltas)  # your driver
        if not running:
            break

Written today, this client is complete and testable except for the id. That is the point of publishing the contract first. The response carries the action chunk, the statistics block the model applied, and a usage object. Metering on this route is per call. One served request is one billed call. A refused request bills nothing. The prepaid wallet balance is the hard stop. Rates for listed models sit on the pricing page, never in prose on pages like this one. For how per-call pricing turns into a cost per robot hour, read the pricing units guide.

Benchmarks

Nothing in this section is this platform's own measurement. A class with no listing has no numbers of ours to publish, and none will be invented. Every figure below carries its owner and its date.

The strongest published action-tier numbers belong to the model you cannot call yet. Google's product page for Gemini Robotics 2, read 2026-10-27, publishes whole-body results on an Apollo humanoid. The model picks from a table at 68.4 percent success, from the floor at 45.7, and from a shelf at 76.3, with two different hand makers. On gripper dexterity with a Franka Duo setup: 74.2 percent on general pick and place, 78.9 on kitting, 89.6 on precise insertion. Those are the vendor's own charts for a private-preview model. They say the capability is arriving. They are not a promise about your robot.

The specialist with the bigger list makes a different claim worth writing down. Robotic Inference states that it tests model families from the big publishers on the same benchmark suites, the same way. It publishes the resulting leaderboard. Same-method comparison is exactly what this market lacks elsewhere, and it is the thing to ask any seller for. The vendor's own fine-tune numbers on the served OpenVLA rows cite their published baselines, around 79 to 88 percent on three of the four LIBERO suites, tuned for one Panda setup in simulation.

Demand numbers close the picture, from the hub's own records read on 2026-10-27. The base SmolVLA checkpoint pulled more than 160,000 downloads in 30 days. OpenVLA-7B pulled more than 110,000. GR00T N1.7 3B pulled more than 65,000, NVIDIA's Alpamayo more than 45,000, and MolmoAct2 more than 30,000. Downloads flow to what is open. Serving does not. That gap, more than any benchmark, is the state of the hosted VLA market. For how a benchmark score does or does not transfer to your arm, read the embodiment stats guide and the LIBERO evaluation guide.

Getting started

1. Read the primaries before the summaries. Start with Google's robotics docs for the reasoning tier. Read the Gemini Robotics page for the action tier's real status. The Pi API beta post covers the waitlist, and the VLA survey counts the models. Every census claim on this page traces to one of them or to a named host's own surface, dated.
2. Knock on the doors in order of fit. Need a catalog this week with a public card: Abstract Inc. Need the widest model list and a machine-readable contract, and can wait for an invite: Robotic Inference. Building around one strong model: the two waitlists. Only need scene reasoning at scale: ER 2, whose card and its January 1, 2027 doubling are covered in the rate card guide.
3. Write the client before you spend. The python tab is the publisher's own self-host pattern, and the action route contract is public today. Whichever door opens, the request shape is the same three inputs and one action chunk, so your driver code survives the choice.
4. On this platform, watch the live list. Create an account on the signup page and make an API key. Check the models index the way the curl tab shows. The written capability record for the model family sits on the VLA page, and cost shapes for anything listed sit on the pricing page. When a VLA id ever appears there, this page's question changes from who serves it to what it costs per call. The answer will be on the pricing page, not in a blog post.