Playground Serve: low-cost, open source robotics inference
Playground Serve is our internal robot inference platform, now free and open source. It runs robot policies on a GPU in your own cloud account. On π0.5 it costs 1.40 to 1.80 USD per robot-hour in compute, 64 to 72% less than comparable hosted alternatives, and it runs MolmoAct2 on LIBERO 5 times faster than the stock code, with the same weights.
A GPU server in your own account
pgs up pi05_libero prints the GPU and its price, then creates a GPU endpoint and a storage volume in your cloud account, today on Runpod (Figure 1). The worker stops 5 minutes after the last client leaves, or sooner after pgs down. The stock path runs the inference code that the model's maker published. The "fast path" is our faster way to run the same model, with the same trained weights, numeric precision, number of steps and inputs, and it only removes waste around that math.
Supported models and families
Serve runs 23 robot policies across 8 families. Most run on an RTX 4090 by default, and --gpu picks another GPU. Table 1 lists every model with its GPU, price and model time.
- π0, π0-FAST and π0.5, from Physical Intelligence's openpi: 9 models for LIBERO, DROID and ALOHA. π0.5 for LIBERO and DROID have run on a GPU, and the other 7 are untested.
- MolmoAct2, from Ai2: 4 models, for LIBERO, DROID, SO-101 and the bimanual YAM.
- GR00T N1.7, from NVIDIA: 4 models for LIBERO. One has run on a GPU, and the other 3 use the same code with other weights and are untested.
- ABC-VLA, from Amazon FAR: 1 model, for the bimanual YAM.
- Xiaomi-Robotics-1: 1 model, for RoboCasa365.
- Flex-π: 1 model, for LIBERO.
- Cosmos 3, from NVIDIA: Edge and Nano, for DROID. Nano is untested.
- FLUX 3 Action, from Black Forest Labs: 1 model, for DROID.
Serve also runs 9 LLM agents, language models that drive a robot through tool calls, which the model list describes.
Cheaper model calls
Figure 3 shows the result for every model. We got there by timing each stage of a call and removing work that does not change the result.
The largest gains came from recording the whole forward pass, the vision encoder, the language model and every action step, as one CUDA graph that the GPU replays as a unit. Xiaomi-Robotics-1's stock code stopped 199 times per call to read a value back from the GPU, each time leaving the CPU waiting, and its action head ran 5 flow steps as 9,000 small GPU operations. The action head then took 16.4 ms instead of 154.2 (Figure 4).
We only remove work whose result nothing uses. π0.5 processed an all-zero third camera image and empty prompt padding, and dropping both took it from 75.0 to 59.9 ms.
Where many small operations remain, a compiler merges them. ABC-VLA ran 6,191 per call, and merged they took 26.2 ms instead of 33.9. We make the compiler round at the same points as the original code.
The math library sized its thread pool by the host's 120 cores, and Flex-π's input step took 124 to 590 ms. With 16 threads, on a host of the same type, it took 3.0 to 4.2 ms.
Never trade accuracy for speed
We self-test at every start before using the "fast path." A new worker can land on another GPU type, driver or library version, or run freshly compiled code, and each of these can shift the output from a model.
The test runs stored observations through both paths, twice, and compares the actions. For π0.5 they may differ by at most 0.1, while new random noise changes them by up to 2.0, and the test measured 0.011. On a failure the worker falls back to the next path and reports why (Figure 5).
Cost
The estimate in the opening uses list prices and counts the GPU while a worker runs, 70 billed seconds of start per session and the volume at 2.80 USD per month.
In our testing as of November 15, 2026, the hosted service of Dreamscale Labs served π0.5 only from us-west-2, at a published price of 5 USD per robot-hour. From a laptop on the US east coast, our RTX 4090 in North Carolina answered about 50 ms sooner than that service at the median, 63.5 against 113.9 ms (Figure 6).
Try it
With a Runpod account, these commands install Playground Serve from the repository, list the models, start a worker, time five calls and stop the GPU.
pip install git+https://github.com/playground-systems/playground-serve
pgs models
pgs up pi05_libero
pgs demo
pgs down
Other models work the same way. GR00T N1.7 and FLUX 3 Action also need a Hugging Face token with their terms accepted.
Model Catalogue
Table 1 lists every entry on the repository's main branch, and pgs models prints the same list with each license. Model time is the median of the server's own timer on the default GPU, and the price is the Runpod list price of that GPU per hour.
| Family | Entries | Robot | Default GPU, USD per hour | Median model time, stock → fast | Status |
|---|---|---|---|---|---|
| π0.5 (openpi) | pi05_libero | LIBERO (sim) | RTX 4090, 1.34 | 75 to 79 → 31 to 34 ms | ran on a GPU |
| π0.5 (openpi) | pi05_droid | DROID | RTX 4090, 1.34 | 86.6 ms, stock path | ran on a GPU |
| π0, π0-FAST, π0.5 (openpi) | pi0_droid, pi0_fast_droid, pi05_aloha, four pi0_aloha_* | DROID, ALOHA | RTX 4090, 1.34 | not measured | untested |
| MolmoAct2 (Ai2) | molmoact2_libero, _droid, _so101, _yam | LIBERO, DROID, SO-101, bimanual YAM | RTX 4090, 1.34 | 521 to 575 → 104 to 139 ms | ran on a GPU |
| ABC-VLA (Amazon FAR) | abc_vla_yam | bimanual YAM | RTX 4090, 1.34 | 84.0 → 28.8 ms | ran on a GPU |
| Xiaomi-Robotics-1 | xiaomi_r1_robocasa365 | RoboCasa365 (sim) | RTX 4090, 1.34 | 267.9 → 65.5 ms | ran on a GPU |
| GR00T N1.7 (NVIDIA) | gr00t_n17_libero, and _goal, _object, _10 untested | LIBERO | RTX 4090, 1.34 | 118.4 → 68.5 ms | ran on a GPU, needs HF_TOKEN |
| Flex-π | flex_pi_libero | LIBERO | RTX 5090, 1.89 | 310.6 → 125.2 ms | ran on a GPU |
| Cosmos 3 (NVIDIA) | cosmos3_edge_droid, cosmos3_nano_droid | DROID | RTX 5090, 1.89 (Nano on A100, 2.99) | 514.0 → 439.5 ms (Edge) | Edge ran on a GPU, Nano untested |
| FLUX 3 Action (Black Forest Labs) | flux3_action_droid | DROID | A40, 1.22 | 3180 to 3228 ms, stock path only | ran on a GPU, needs HF_TOKEN |
| LLM agents (through OpenRouter) | fable_5_2, opus_5_5, gemini_4_carbon, gemini_4_argon, gemini_3_8_flash_high, gpt_6_astra, gpt_6_1_sol, muse_wonder_1_0, kimi_3_1 | any robot with an embodiment card | CPU (cpu3c, 2 vCPU), 0.072 | seconds to minutes per model call | answered a tool call with images, needs OPENROUTER_API_KEY |
--gpu picks another. Flex-π is the one exception, because pgs up starts it on the A40 unless you pass --gpu "RTX 5090". Untested entries have not run on a GPU yet. The README and MODELS.md hold the same list with licenses, first start times and other GPUs.The LLM agents are language models that drive a robot through tool calls. Each model runs at its provider and is reached through OpenRouter, and a CPU worker in your account holds the agent loop and turns the model's targets into robot actions. Each episode starts from an embodiment card that the client sends, which names the robot, its action space and its cameras. A model call takes seconds to minutes, against milliseconds for the policies above.
Methodology
Model time is the server's own timer around one call. For the model families it includes decoding the images and is the median of 8 to 40 calls on one worker of the model's default GPU, measured on November 16, 2026. For π0.5 the stock time is the median of 40 calls inside one worker and the fast time, with image decoding, the median of 1,000 served requests, both on November 14. Where GPUs round differently, the self-test compares against a stock reference stored for that GPU. Of the openpi models other than π0.5 for LIBERO, only π0.5 for DROID has run on a GPU, on its stock path. These numbers and their conditions are in the repository's MODELS.md, BENCHMARKS.md and each family's NOTES.md.
The runs of Figure 2 used one Runpod Serverless worker with an RTX 4090 in North Carolina and a laptop on home Wi-Fi on the US east coast. Figure 2 shows the back to back run and the second run at 5 per second, the one the repository's benchmarks report. The placement result came from the same laptop, which took turns between the services in blocks of 50 requests on November 14, 2026 (UTC), with 1,000 requests per service sent back to back.
Evaluate your model with Playground.
Tell us about your model and what you’d like to test. We’ll help scope a custom evaluation or work with you to add your policy to the Robot Intelligence Index.
Thanks, request received.
We’ll be in touch shortly.