Run AI in orbit.
The cloud can't.
Kubernetes doesn't understand orbital mechanics. PyTorch doesn't adapt to solar eclipses. TensorFlow doesn't expect bit flips. We build the runtime that does.
from rotastellar import RotaStellarClient client = RotaStellarClient(api_key="rs_live_...") # plan a workload under power, thermal, link budgets plan = client.cae.plan( satellite="OC-LEO-7", preset="onboard-ml-inference", constraints={"energy_budget": 340}, # watts ) print(plan.estimated_cost) # $0.84 # deploy · the agent runs it, streams events deploy = client.deployments.create(plan_id=plan.id) for event in deploy.stream(): print(event) # step.run_inference → running
Plan it. Run it on-orbit. Coordinate the fleet.
Constraint-aware planning
Takes a workload and a satellite, models power, thermal, comms, and orbital windows, and returns a feasible execution plan in under two seconds - or an explicit reason it can't be done.
Execution that survives orbit
A Rust runtime on the spacecraft executes the plan, reports power and radiation, pauses on eclipse, resumes on sun, and recovers from single-event upsets - no operator in the loop.
Coordinated compute
Federated training, model partitioning, and bandwidth-aware synchronization across ground and orbital nodes, so a single job spans Earth and space.
Ship a model to space in a few lines.
Bring a model and a preset. We handle the orbit - the runtime plans the run, executes it on a node, and returns results and cost.
- Deploy inference or training with one call
- Radiation-tolerant execution, eclipse-aware scheduling
- Cost and power budget returned before you commit
Turn your fleet into compute nodes.
Register a satellite as an orbital compute node and run workloads strictly inside its power, thermal, and link budgets.
- Set eclipse and power policies per node
- Autonomous recovery from faults and SEUs
- Live telemetry and fleet-wide mission control
Ship from Python, Rust, or Node.
One runtime, three first-class SDKs. Install, point at a target, and CAE plans the run while the agent executes it on-orbit.
Plan runs, check feasibility, and track satellites from your existing Python stack.
High-performance orbital planning and tracking - native or compiled to WASM.
Web-native tracking, feasibility, and distributed-compute coordination.
Latest writing & research
Inside CAE: How a Feasible Plan Gets Built in Under Two Seconds
An engineering view of CAE, the constraint-aware execution planner from RotaStellar. We walk the four-phase pipeline (orbital e...
Read →Compute Isn't a Placement Problem Anymore
Placement was the primitive of the cloud era. Planning against time-varying constraints is the primitive of what comes next. Or...
Read →Introducing the Rotastellar Operator Agent
RotaStellar now has an execution layer. The Operator Agent SDK is a Rust crate that runs on satellites, executes workloads, and...
Read →Where this is going.
Today the runtime plans a workload, proves it feasible, and runs it through the agent. Next, it takes the model end to end. These are previews of what we're building - not live yet.
Hand the runtime a model and a target; it plans, deploys, and runs inference on-orbit - the full "run AI in orbit" loop, in one call.
Plans already compute energy cost under the hood; dollar pricing is the next field on /v1/plan.
Put your first workload in orbit.
Tell us what you want to run and the satellite you want to run it on. We'll come back with a feasible plan - or an honest reason it can't be done yet.