The software layer for orbital compute

The Cloud Breaks in Space.
We're Fixing It.

Kubernetes doesn't understand orbital mechanics. PyTorch doesn't adapt to solar eclipses. TensorFlow doesn't expect bit flips. We're building the runtime that does.

Explore Platform Get Early Access Live Tracker

rotastellar-cae

$ curl /v1/plan -d '{
    "satellite": "OC-LEO-7",
    "preset": "onboard-ml-inference"
  }'

# CAE returns a constraint-aware plan
{
  "satellite": "OC-LEO-7",
  "altitude_km": 550,
  "plan": {
    "steps": 4,
    "duration": "22 min",
    "power_required": "340W peak",
    "eclipse_in": "43 min",
    "orbital_window": "CLEAR"
  },
  "estimated_cost": "$0.84",
  "status": "ready"
}

14,000+

Active satellites tracked in real-time

Mission Control

Plan, deploy, monitor

Open Source

Rust agent SDK on GitHub

Why Cloud Assumptions Break

Space compute isn't just "AWS in orbit." Every cloud assumption fails.

Always-on network

Intermittent: eclipses, orbital motion, ground station handovers

Stable power

Variable: solar flux cycles, eclipse periods, battery limits

Low, predictable latency

LEO: 5-40ms RTT; GEO: 240ms+; ISL hops add variability

Reliable hardware

Radiation causes bit flips; SEUs are normal, not exceptional

Manual intervention

Near-zero tolerance — you can't send a technician to LEO

Four Layers. One Platform.

Plan, understand, execute, coordinate — the complete stack for orbital compute.

Planning Tools

Feasibility analysis, thermal modeling, latency simulation, power budgeting. Answer "should we?" before "how?"

Explore → 02

Orbital Intelligence

Track 10,000+ objects, analyze conjunction risks, detect anomalies. The situational awareness layer runtime depends on.

Explore → 03

Orbital Runtime

Execute workloads in orbit. CAE scheduler plans, Operator Agent executes on-satellite, Mission Control manages fleets and real-time telemetry.

Live Explore → 04

Distributed Compute

Coordinate AI across Earth and space. Federated learning, model partitioning, and bandwidth-optimized synchronization for hybrid infrastructure.

Explore →

Built for teams pushing compute to orbit

If you're operating satellites, planning space infrastructure, or extending AI beyond Earth — this platform is for you.

Satellite Operators

Collision avoidance, fleet management, conjunction analysis across your constellation.

Orbital Intelligence

AI Companies

Energy-efficient training and radiation-tolerant inference on orbital compute nodes.

Runtime + Distributed

Space Data Centers

Feasibility studies, thermal design, and workload scheduling for orbital facilities.

Orbital Runtime

Cloud Providers

Orbital expansion planning and latency modeling for hybrid Earth-space infrastructure.

Planning Tools

Defense & Intelligence

Space domain awareness, pattern analysis, and real-time orbital monitoring.

Orbital Intelligence

Research Institutions

Orbital mechanics research, ML model development, and full platform access for experimentation.

Full Platform

Developer SDK

Build orbital compute into your applications.

rotastellar

Python SDK — satellite tracking, CAE planning, deployments. Unified client for the full API.

pip install rotastellar

PyPI Docs GitHub

rotastellar-agent

Rust SDK for orbital compute providers. Implements the Operator Protocol for on-satellite execution.

cargo add rotastellar-agent

Docs GitHub

from rotastellar import RotaStellarClient

client = RotaStellarClient(api_key="...")

# Plan a workload with orbital constraints
plan = client.cae.plan(
    satellite="OC-LEO-7",
    preset="onboard-ml-inference",
    constraints={
        "energy_budget": 340,     # Watts
        "eclipse_policy": "pause",
        "radiation_tolerance": "moderate"
    }
)

# CAE returns constraint-aware scheduling
print(plan.orbital_windows)   # When to execute
print(plan.power_allocation)  # Per-step energy
print(plan.estimated_cost)    # $0.84

# Deploy — the agent handles the rest
deployment = client.deployments.create(
    plan_id=plan.id
)
for event in deployment.stream():
    print(event)
    # step.upload_model → completed
    # step.run_inference → running
    #   (247W, eclipse in 43min)
    # job.completed → 4 steps, 0 failures

use rotastellar_agent::{Agent, Config};

async fn main() -> Result<()> {
    // Register this satellite as a compute node
    let agent = Agent::builder()
        .satellite_id("OC-LEO-7")
        .capabilities(["inference", "training"])
        .power_monitor("/dev/pmu0")
        .build()?;

    // Connect to ground station relay
    agent.connect(Config::from_env())
        .await?;

    // Agent handles the Operator Protocol:
    //   → receives deployment plans
    //   → reports power, thermal, radiation
    //   → executes steps within constraints
    //   → pauses on eclipse, resumes on sun
    agent.run_forever().await
}