Every action.
The right policy.
An open, programmable decision layer for robots. Solo Router sends each instruction to the best-fit VLA, planner, VLM, or safety controller — across onboard, edge, and cloud compute. Bring your own OpenAI, Claude or Nebius key and run it in one click.
Perceive. Reason. Act.
One instruction, three routing decisions, one SO-101 arm. Watch the router pick a perception model, a planner and a policy, or switch to running real ONNX models on your own GPU.
No single model drives a robot.
A fold, a hallway, a stop command and a ten-step chore need different models, different compute and different deadlines. Today that logic is hard-coded into every robot stack.
Control loops don't wait
A 30 Hz policy gets 33 ms per step. A cloud round-trip costs seconds. The router knows which models can keep up.
Networks drop
Warehouses, farms and basements lose Wi-Fi. Offline robots never call the cloud; degraded links prefer the edge.
Safety is not a model
"Stop" goes to a deterministic controller in milliseconds, before any learned model sees it. Every route ends in a fail-safe.
Bodies differ
An arm, a humanoid and a quadruped need different policies. Routing matches each request to models trained for that body.
See. Think. Move.
The router ships with a model pool grouped by role. Each request uses the model in the role it needs, on whatever compute it can reach, including your browser.
Get started in one line.
$ pip install git+https://github.com/ddiddi/solo-router $ export ANTHROPIC_API_KEY=sk-ant-... # or OPENAI_API_KEY / NEBIUS_API_KEY $ solo-router run "plan how to clear the table, then wipe it" [long_horizon_task -> anthropic/claude-sonnet-5-5 @ cloud] 1. move_above(plate) ... $ solo-router serve --proxy # OpenAI-compatible on :8899
$ curl localhost:8899/v1/chat/completions -d '{ "model": "solo/auto", "messages": [{"role": "user", "content": "hand me the scissors"}], "robot": {"embodiment": "arm", "observations": ["rgb"], "control_hz": 20, "humans_nearby": true} }' # x-solo-router-decision: realtime_manipulation # x-solo-router-model: pi0-3b # x-solo-router-safety: elevated (max 0.25 m/s, 20 N)
Python 3.10+. The server uses only the standard library, so it runs on the robot itself.
One endpoint. Every model your robot needs.
A unified, OpenAI-compatible API for robot policies and hosted models, with routing, fallbacks and a safety envelope across onboard, edge and cloud. Bring your own OpenAI, Claude or Nebius Token Factory key.
Any one key is enough
Add a key and the router uses that provider for cloud work, and the robot's own models for everything else. No key: it stays self-hosted.
Switch models in config
Models are provider/model IDs in one YAML file. Change the pool or the provider, not the robot.
Route around outages
If a provider fails or rate-limits, the request falls through to the next model. Every chain ends at the safety controller.
No account, no markup
Keys live in your env, a per-request header, or this browser. You pay each provider directly at its own price.
One prompt. One click.
Type an instruction and press Run. The real router picks a model; with your OpenAI, Claude or Nebius Token Factory key it calls that model and shows the answer. Keys stay in your browser and go straight to the provider.
Your robots. Your rules.
Four dimensions decide where an instruction should run. You write them down once, in YAML, and every robot in the fleet follows them.
Policies
VLAs for manipulation, navigation policies, VLMs for perception, planners for long tasks.
Compute
Jetson-class boards on the robot, a GPU box on the LAN, or frontier APIs in the cloud.
Connectivity
Online, degraded or offline. Cloud is penalized on a weak link and never used without one.
Control loop
A control rate becomes a latency budget. Models that can't meet it are filtered out before scoring.
One frontend. Every policy behind it.
Robots talk to one endpoint. The decision engine picks the policy; the pool runs it wherever it lives.
Frontend
OpenAI-compatible, plus robot-native routes.
/v1/chat/completionschat/v1/actionspolicy/v1/routedecide only/v1/modelscatalog
Decision engine
Deterministic, explainable, and traced on every request.
- intent · horizon · safetywhat
- embodiment · modalitieswho
- latency · network · batteryconstraints
Policy pool
Wherever each model runs best.
- safety-controlleronboard
- smolvla · nav-policyonboard
- π0 · GR00T · Qwen-VLedge
- frontier plannercloud
Dry-run mode
Returns the decision and trace without calling any backend. Use it on a laptop, in CI, or to audit a new policy before it touches hardware.
$ solo-router serve
Proxy mode
Forwards chat to OpenAI-compatible backends and observations to policy servers' /act. Falls back down the chain if a backend is unreachable.
$ solo-router serve --proxy
Your robot. Your safety envelope.
Routing is where safety policy belongs: before any model runs, in code you can read.
- Stop preempts everything. "Stop", "halt" and e-stop flags go to a deterministic controller at the highest priority.
- Elevated risk tightens limits. Knives, heat or people nearby cap speed and force, and only higher-tier policies stay eligible.
- Every chain ends in a fail-safe. If no policy qualifies, the robot holds position instead of guessing.
- Data stays where you put it. Offline robots never route to the cloud. Camera frames go only to models you list.
Papers behind the router.
Solo Router applies signal-driven routing from LLM serving to the policies that move robots.