Alternatives to OpenVLA: the hosted ways to run it, answered

There is no official OpenVLA API to switch from. Checked on October 27 2026, the real alternatives are four paths. Run the open weights on a rented GPU card. Try OpenVLA-OFT, the faster recipe the OpenVLA makers themselves now recommend. Run a smaller open model on hardware you already own. Or call a specialist host that serves four OpenVLA fine-tunes per call today. Every rate on this page carries its party and its date. Where a party publishes nothing, the table cell stays a dash.

Google's own overview, read on the same day, agrees on the gap. Its words: there is "no singular, direct public cloud API service designed to host OpenVLA out-of-the-box on a pay-per-call basis". This page is the comparison that gap leaves empty. It prices the self-host path with dated rental rates and names the one host found serving OpenVLA checkpoints. The page also splits the model-swap question from the hosting question, because the search results mix the two together.

What people actually ask

Two signals, both re-checked on October 27 2026. First, autocomplete. The box completes the full string "openvla api" as you type it, and the bare word "openvla" suggests "openvla-oft" second, with "openvla hardware requirements" appearing third once you type the h. People are asking for an API that does not exist and for the hardware floor of the path that does. Second, the pages that rank where a host would be. The top rows on every variant of this query are the model's own pages plus one GPU-cloud self-host guide. The comparison pages that exist compare model against model. None of them answers the buying question: where can I run this without my own GPU.

Under those searches sit five real questions. Does anyone host OpenVLA for me. Can I run it without a GPU at all. What is the lowest-cost way to run it this week. Should I switch to a different open model instead. And what does the fine-tuned version, OpenVLA-OFT, change. The rest of this page answers each in order.

What OpenVLA is, and why the question exists

OpenVLA is a 7-billion-parameter open vision-language-action model, released in June 2024 by a Stanford and Berkeley led team. The project page, the repository, and the model card carry it. It reads one camera image and one instruction. It predicts one 7-number action: arm moves plus gripper. Per the paper, it needs about 15 GB of GPU memory in standard precision. On one RTX 4090 it runs at roughly 6 Hz, without speed tricks. A control loop usually wants about 10 Hz. That mismatch is why the hosting question exists. The model is open, but it is not small.

One fact about the license, because product teams ask. The repository ships its code under MIT and states plainly that the pretrained models derive from Llama 2 and are subject to the Llama Community License. The card's own tag says MIT. Two artifacts, two statements. Read the repository note before you ship a product.

The community scale is real: 131,912 downloads of the base checkpoint in the last 30 days, read from the model data on October 27 2026. Downloading is the easy part. The serving is the work, and that is what the rest of this page divides into paths.

Path A: run the open weights on a rented card

This is the default alternative and the one the search results push you toward. The makers ship a serving script in the repository, vla-scripts/deploy.py. It is a small REST server: install three packages on a GPU machine, start it, and it listens on port 8000. Your robot posts a 256 by 256 image and a plain instruction to one address and gets a 7-number action back. For machines not open to the web, the script's own header suggests forwarding the port over ssh. That is the whole official serving path. You bring the GPU.

Rented cards, named parties, rates read on October 27 2026. The RunPod pricing page lists its 24 GB cards at 0.16 per hour on an A5000, 0.22 on an RTX 3090, and 0.34 on an RTX 4090 on the community tier, and 0.27, 0.5, and 0.89 on the secure tier. Spheron's deployment guide, which dates its own figures as of October 27 2026, lists on-demand rates of 2.64 per hour for an H100, 1.43 for an A100 80 GB, and 0.96 for an L40S. The 24 GB tier serves the base model, since the weights need about 15 GB. Fine-tuning is the fork: the repository's LoRA recipe names a single 80 GB A100, says smaller cards work down to about 27 GB, and puts a full tune on eight A100s. A 24 GB card therefore serves but cannot start the fine-tune. Rates move; treat every number here as a snapshot with a date, including these.

One piece of the self-host path changed recently, and the ranking guide has not caught up. The Spheron guide tells readers that OpenVLA "is not on vLLM's official supported model list". Yet the vLLM supported models list, read on October 27 2026, now carries an OpenVLA row of its own. The row sits under the architecture name OpenVLAForActionPrediction. It takes text and image inputs, and it names the base checkpoint as the example model. The feature request behind it was closed without a plan in March 2026. The support landed anyway. If you want the high-throughput engine rather than the plain script, the door is open today in a way it was not when that guide was written. Test on your own setup. Engine support and a robot-ready server are different things.

Path B: run OpenVLA-OFT, the recipe the makers recommend

Before you rent anything, read what the repository now says at the top of its fine-tuning section. Since March 2025 the OpenVLA makers recommend trying OpenVLA-OFT. It is a later recipe from a Stanford team that builds on their model. In their own words, it enables 25 to 50 times faster inference, higher task success rates, and high-frequency two-arm control. The OpenVLA-OFT project page reports a 97.1 percent average across the four LIBERO suites. It also reports 26 times faster action generation than the base model. For a robot that needs speed, this is not a downgrade from OpenVLA. It is the same backbone with the slow part replaced. It predicts a chunk of continuous actions in one pass instead of one binned action at a time.

The hardware story improves too. The project's own memory table, read on October 27 2026, puts serving at 15.9 GB for the one-camera setup, 16.2 GB with a second camera and joint state, and 18.0 GB for the two-arm setup. Fine-tuning starts at 25.6 GB. Each of the five public checkpoints carries an MIT license tag on its model card. The catch has not changed: OFT is still a 7-billion-parameter model to serve, and no marketplace sells it either, a fact with its own guide on the OpenVLA-OFT pricing page.

This platform keeps a written record for the openvla-oft model id on its action route. The facts of that record, as of October 27 2026: the row sits in the platform's model data, metering is per call, the rate is set, and the row is not on the public list. No date is attached to that. This page quotes no live rate. The models index is the live catalog, and rates for listed rows render on the pricing guide. The model's own page is openvla-oft.

Budgeting that shape is arithmetic on named inputs:

cost per robot hour  =  C x P

C:  calls per robot hour, set by your control loop and the chunk length
P:  per-call rate, read off the live table for a listed row

One sensitivity line. At a 30 Hz loop with a chunk of 8 actions, a robot hour costs about 13,500 calls; halve the chunk and you double the bill at any fixed rate. The prepaid wallet balance is the hard stop on that arithmetic, and a refused call bills nothing. The bill shock guide explains why that matters for unattended robots.

Path C: smaller open models on hardware you already own

If the question is really "how do I get VLA behavior without buying a GPU", shrink the model first, not the hosting. Three open checkpoints, all read on October 27 2026. All three show zero hosted inference on the hub.

SmolVLA, from the LeRobot project, is the practical one: 450 million parameters under Apache 2.0, with 163,364 downloads in 30 days. Its own card describes it as trainable on a single GPU and deployable on consumer hardware. The platform keeps a written record for the smolvla id on the same action route, in the same state as the OFT row above: not on the public list, no date, rate set in the model data. Its deep treatment is the SmolVLA pricing page.

The pi 0.5 open weights are the middle option. The openpi repository publishes the checkpoints from Physical Intelligence, with an inference floor of more than 8 GB of GPU memory, a LoRA floor above 22.5 GB, and a full-tune floor above 70 GB, per its own requirements table. On this platform, the written record for pi05 sits in the same shape. That family has its own alternatives guide, the Physical Intelligence alternatives page.

X-VLA, a 0.9-billion-parameter newcomer, rounds the shelf out at 6,200 downloads a month. The wider model class, with the trade-offs spelled out, is the VLA explainer.

And the direct "without gpu" question deserves the direct answer. A 7-billion-parameter model on a CPU takes seconds to minutes per step. A robot loop wants about 100 milliseconds. Google's own overview, read on October 27 2026, calls CPU running useless for live control, and the paper's numbers agree with it. There is no clever workaround. The realistic no-GPU paths are a rented card, a hosted fine-tune from the next section, or a small model on whatever GPU you can borrow. For the budget side of that choice, the hobbyist compute budget guide works the tiers.

Path D: who serves it for you today

Now the host surface, checked on October 27 2026. This is where most "alternatives" content stops at the weights. A host has to serve.

Hugging Face holds the weights and serves none of them. The model's own data on the hub carries no inference provider, and a provider search across every openvla checkpoint returns zero results. The hub hands you files. Running them stays yours.

The big marketplaces do not carry it. Replicate, fal, DeepInfra, and the rest were read on their own catalog pages the same week this page was written, and none of them lists an OpenVLA policy or any robot policy. The big hosts survey holds that full record with its dates.

One specialist does serve OpenVLA. Robotic Inference, a robot API site, publishes its served model list as open data. Read on October 27 2026, it carried 24 robot policies. Four were OpenVLA 7B fine-tunes, one per LIBERO suite. Every one showed a running status. The published baselines are about 79 percent on Goal, 88 on Object, 85 on Spatial, and 53 on the long-horizon suite. Two honest limits follow. Those checkpoints are tuned for one simulated Panda arm setup. They answer benchmark questions, not your arm on your bench. And the site publishes no prices. The offer is public. The rate card is not. Ask for it before you spend engineering time.

One specialist publishes prices, but not for OpenVLA. Abstract's pricing page, read in full on October 27 2026, lists six robot models, pi 0.5 and MolmoAct2 among them, priced per million input tokens and per million actions. The pi 0.5 row lists 0.15 per million input tokens, 3.70 per million actions, and an hour estimate of 0.85 for a 30 Hz loop, which they define as 108,000 actions. Their isaac-0.5 row estimates 4.05 for the same hour, about five times the pi 0.5 figure on the same card. No OpenVLA row exists anywhere on that card. So the priced robot APIs today are for other models, and the served OpenVLA today is unpriced. That cross is the whole market in two sentences.

Managed fine-tuning exists as a half-path. An AWS blog post from June 28 2026 walks fine-tuning OpenVLA with LoRA on SageMaker, on a named 8-GPU instance class (eight 48 GB cards), in hours rather than days. Useful when the tuning is the bottleneck. It ends by handing you weights, not an endpoint.

The comparison, in one table

Read on October 27 2026. A dash is a fact with a date on it: the party publishes nothing there.

The two dashes in the Robotic Inference row carry this page's argument. So does the empty serving column at Hugging Face. Absence, dated, is information.

How to choose

Work down the list. Stop at the first line that fits.

1. You own a 24 GB card and want the real OpenVLA: run the makers' script today. Fine-tune with OFT, not the base recipe.
2. You own nothing and want it running this week: rent the 24 GB tier from any provider named above, or ask the specialist host for its rate card and its four fine-tunes.
3. Your robot is not a LIBERO Panda arm: the hosted fine-tunes will not move it. Self-host, or take the written-record route and fine-tune on your own data.
4. Your real constraint is the GPU bill, not the model: try SmolVLA first. The hardware floor drops by an order of magnitude and the license is Apache 2.0.
5. You need speeds past 10 Hz: OFT, or the pi 0.5 family, both built for chunked output. The base model's one-action design is the ceiling no host can lift.

For the local-versus-hosted arithmetic on any of these, the VLA break-even guide runs the full math. The measured case is the cost per robot hour report. To move between per-call and per-hour cards, read the pricing units guide.

Common questions

Is there any hosted OpenVLA API?

One, in a narrow form. The specialist host serves four official LIBERO fine-tunes of the 7B model, all running on October 27 2026, at no published price. For the base checkpoint, no per-call route exists anywhere: not from the makers, not on the hub, not at the marketplaces. The makers' own serving script is a self-host tool, not a product.

How do I run OpenVLA without a GPU?

You rent one, or you call someone else's. Pure CPU running exists in the technical sense and fails in the practical one: seconds per action against a loop that wants ten per second. Google's overview and the paper agree. The entry path is a rented 24 GB card, which cost 0.16 to 0.89 per hour at one provider on October 27 2026, community to secure tiers.

What is the best alternative to OpenVLA?

There is no single best, and any page that names one without your constraints is guessing. The choice splits on two axes. If hosting is the problem, the paths are rent, specialist host, or written record. If the model is the problem, OpenVLA-OFT keeps the backbone and fixes the speed, SmolVLA drops the hardware floor, and the pi 0.5 open weights sit between them.

Is OpenVLA-OFT a different model or the same one?

Both, usefully. It is the same Prismatic backbone, retrained with a recipe that changes the output side. Actions come out continuous, in chunks, in one pass. The OpenVLA repository itself recommends it over its own original fine-tuning recipe, in a note dated March 2025. The checkpoints are MIT tagged. Serving memory stays in about the same band as the base model's.

Can this platform run OpenVLA for me?

Today the platform's action route carries written records for eight robot models. openvla-oft is among them. None are on the public list, and none carry a date for that. A written record is not a launch, and this page promises nothing. What is fixed and public today is the contract. Four form fields go in. An action chunk comes out. Metering is per call. The wallet is the hard stop. You can sign up, create a key, and write the client against that contract now. The models index settles the listing question any day you ask it. The pricing guide renders rates for listed rows.

The short version: no official API exists. Self-hosting costs a rented 24 GB card by the hour. The makers' own recommended upgrade is OFT. One specialist serves four fine-tunes, unpriced. Priced robot cards serve other models. Every number above carries a party and a date. When you are ready to budget metered calls, the current rates are on the pricing guide, and signup is where the key comes from.

Last verified: 2026-10-27