Playground Serve: low-cost, open source robotics inference

PlaygroundNovember 18, 2026Open source release

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.

How a request reaches the modelone model, one worker
Robot client Gateway checks your API key routes to the worker direct port, opt in pinned certificate, no gateway hop GPU worker Self-test at start fast against stock actions passes fails Fast path same weights, steps, inputs Stock path the maker's own code one model per worker stops 5 minutes after use Volume environment weights compile caches checked copies Your computer pgs up MODEL pgs down creates the endpoint and the volume
Robot client Gateway checks your API key direct port, opt in, pinned certificate GPU worker Self-test at start fast path against stock actions passes fails Fast path same weights, steps Stock path the maker's own code stops 5 minutes after use Volume environment, weights, compile caches Your computer pgs up MODEL creates the endpoint and the volume, pgs down stops it
playground/Playground Serve
Figure 1. The client reaches the worker through the gateway, or with the direct port straight on the worker's own port. At every start the worker tests its fast path against the stock path and serves the stock path if the test fails. The volume keeps what later starts need.
Round trip and model time over two runs of π0.5fast path, one RTX 4090 in North Carolina
0 20 40 60 80 0 200 400 600 800 1000 Request number in the run Milliseconds round trip, 5 per second median 65.7 ms round trip, back to back median 61.1 ms model time, back to back median 31.4 ms
0 20 40 60 80 0 200 400 600 800 1000 Request number in the run Milliseconds round trip, 5 per second median 65.7 ms round trip, back to back median 61.1 ms model time, back to back median 31.4 ms
playground/Playground Serve
Figure 2. π0.5 on its fast path, served by one RTX 4090 worker in North Carolina to a laptop on the US east coast, 1,000 requests per run. Each line is a rolling median over 25 consecutive requests, so single slow requests do not show, and the gap between round trip and model time is the network.

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.

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.

Model time per call, stock path against fast pathmedian on each model's default GPU
stock path, the maker's code fast path 0 100 200 300 400 500 600 Model time per call, ms, median π0.5 LIBERO, RTX 4090 75.0 to 31.4 ms ABC-VLA bimanual YAM, RTX 4090 84.0 to 28.8 ms Xiaomi-Robotics-1 RoboCasa365, RTX 4090 267.9 to 65.5 ms GR00T N1.7 LIBERO, RTX 4090 118.4 to 68.5 ms MolmoAct2 LIBERO, RTX 4090 520.7 to 104.2 ms MolmoAct2 DROID, RTX 4090 532.0 to 104.8 ms MolmoAct2 SO-101, RTX 4090 565.5 to 111.8 ms MolmoAct2 bimanual YAM, RTX 4090 574.8 to 139.3 ms Flex-π LIBERO, RTX 5090 310.6 to 125.2 ms Cosmos 3 Edge DROID, RTX 5090 514.0 to 439.5 ms
stock path, the maker's code fast path 0 200 400 600 Model time per call, ms, median π0.5 75.0 to 31.4 ms LIBERO, RTX 4090 ABC-VLA 84.0 to 28.8 ms bimanual YAM, RTX 4090 Xiaomi-Robotics-1 267.9 to 65.5 ms RoboCasa365, RTX 4090 GR00T N1.7 118.4 to 68.5 ms LIBERO, RTX 4090 MolmoAct2 520.7 to 104.2 ms LIBERO, RTX 4090 MolmoAct2 532.0 to 104.8 ms DROID, RTX 4090 MolmoAct2 565.5 to 111.8 ms SO-101, RTX 4090 MolmoAct2 574.8 to 139.3 ms bimanual YAM, RTX 4090 Flex-π 310.6 to 125.2 ms LIBERO, RTX 5090 Cosmos 3 Edge 514.0 to 439.5 ms DROID, RTX 5090
playground/Playground Serve
Figure 3. Each line runs from the stock path to the fast path. FLUX 3 Action runs on its stock path, at 3180 to 3228 ms per call on an A40.

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).

Where one Xiaomi-Robotics-1 call spends its timeRTX 4090, median per stage
stock path fast path 0 50 100 150 200 250 300 Milliseconds, median Image decoding and server camera frames sent as JPEG 12.0 6.7 Building the request crops, text template, tokens 16.6 1.3 to 1.5 Vision encoder the camera images 17.2 10.6 Language model stock adds scores nothing uses 53.8 31.4 Action head 5 flow steps 154.2 16.4 Whole call, served the server's own timer 267.9 65.5
stock path fast path 0 100 200 300 Milliseconds, median Image decoding and server camera frames sent as JPEG 12.0 6.7 Building the request crops, text template, tokens 16.6 1.3 to 1.5 Vision encoder the camera images 17.2 10.6 Language model stock adds scores nothing uses 53.8 31.4 Action head 5 flow steps 154.2 16.4 Whole call, served the server's own timer 267.9 65.5
playground/Playground Serve
Figure 4. Grey bars are the stock path and blue bars the fast path, on one RTX 4090. The largest cut is in the action head, whose 5 flow steps ran as 9,000 small GPU operations in the stock code. Each stage was timed on its own, so the stages do not add up to the whole call.

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).

What the worker serves after its self-testthe fallback order at every start
Worker starts Compiled fast path fused, original rounding self-test passes serves fails Uncompiled graph recorded call, bit-identical self-test passes serves fails Stock path the maker's own code always serves Self-test at every start stored observations, fast against stock at the same noise, within 0.1 max and 0.01 mean, twice For scale, a new noise draw moves actions by about 2.0
Worker starts Compiled fast path fused, original rounding passes serves fails Uncompiled graph recorded call, bit-identical passes serves fails Stock path the maker's own code always serves Self-test, fast against stock at the same noise within 0.1 max and 0.01 mean, twice a new noise draw moves actions by about 2.0
playground/Playground Serve
Figure 5. Xiaomi-Robotics-1 and ABC-VLA try all three paths in this order, with the bounds shown. The other families try their fast path and then the stock path.

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).

π0.5 from the US east coast, our RTX 4090 against Dreamscale Labsmedians back to back, interleaved run
median model time, then median network time 0 25 50 75 100 125 150 Round trip back to back, ms Playground Serve RTX 4090 in US-NC-1, North Carolina round trip 63.5 ms (63.0 to 63.8), model 32.0, network 31.1 50.5 ms sooner than Dreamscale Labs (49.6 to 51.5), in 20 of 20 rounds Dreamscale Labs H100 in us-west-2, hosted round trip 113.9 ms (113.1 to 114.9), model 29.5, network 84.0
median model time, then median network time 0 50 100 150 Round trip back to back, ms Playground Serve RTX 4090 in US-NC-1, North Carolina 63.5 ms (63.0 to 63.8), model 32.0, network 31.1 50.5 ms sooner (49.6 to 51.5), in 20 of 20 rounds Dreamscale Labs H100 in us-west-2, hosted 113.9 ms (113.1 to 114.9), model 29.5, network 84.0
playground/Playground Serve
Figure 6. One laptop on home Wi-Fi on the US east coast took turns between the services in blocks of 50 requests on November 14, 2026 (UTC), 1,000 requests to each back to back. Each bar splits the median round trip into model time and network time, the dashed line marks Dreamscale's median, and the difference is paired by round with its 95 percent interval.

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.

The models Playground Serve runsdefault GPU and median model time
FamilyEntriesRobotDefault GPU, USD per hourMedian model time, stock → fastStatus
π0.5 (openpi)pi05_liberoLIBERO (sim)RTX 4090, 1.3475 to 79 → 31 to 34 msran on a GPU
π0.5 (openpi)pi05_droidDROIDRTX 4090, 1.3486.6 ms, stock pathran on a GPU
π0, π0-FAST, π0.5 (openpi)pi0_droid, pi0_fast_droid, pi05_aloha, four pi0_aloha_*DROID, ALOHARTX 4090, 1.34not measureduntested
MolmoAct2 (Ai2)molmoact2_libero, _droid, _so101, _yamLIBERO, DROID, SO-101, bimanual YAMRTX 4090, 1.34521 to 575 → 104 to 139 msran on a GPU
ABC-VLA (Amazon FAR)abc_vla_yambimanual YAMRTX 4090, 1.3484.0 → 28.8 msran on a GPU
Xiaomi-Robotics-1xiaomi_r1_robocasa365RoboCasa365 (sim)RTX 4090, 1.34267.9 → 65.5 msran on a GPU
GR00T N1.7 (NVIDIA)gr00t_n17_libero, and _goal, _object, _10 untestedLIBERORTX 4090, 1.34118.4 → 68.5 msran on a GPU, needs HF_TOKEN
Flex-πflex_pi_liberoLIBERORTX 5090, 1.89310.6 → 125.2 msran on a GPU
Cosmos 3 (NVIDIA)cosmos3_edge_droid, cosmos3_nano_droidDROIDRTX 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_droidDROIDA40, 1.223180 to 3228 ms, stock path onlyran 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_1any robot with an embodiment cardCPU (cpu3c, 2 vCPU), 0.072seconds to minutes per model callanswered a tool call with images, needs OPENROUTER_API_KEY
playground/Playground Serve
Table 1. Each entry runs on the GPU shown unless --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.