Autonomous decision-making for satellite operations.
The control plane that owns operational decisions when systems drift from plan. Reasons under uncertainty. Executes across vendors. Escalates only when required.
Locus autonomously managing a 5-satellite constellation. Failures, weather, and station outages happen stochastically. Watch how the system continuously reconciles toward declared intent.
Failure rates are exaggerated for demonstration.
Real operations would see higher success rates.
This simulation runs entirely client-side. The decision engine evaluates constraints, calculates confidence, and executes or escalates — exactly as it would in production. Every decision is logged, explained, and attributable.
Modern satellite operations fail at scale because judgment does not scale.
Locus replaces ad-hoc human triage with a system that is consistent, explainable, and bounded by operator intent. Think of it as Kubernetes for satellites — a runtime that continuously reconciles actual state with declared intent.
"What is the current state? What should it be? What's the best path from here to there?"
Observe actual state across the constellation.
Compare against declared intent and constraints.
Evaluate options. Account for physics, risk, uncertainty.
Execute — or escalate to humans when confidence is insufficient.
Locus is not a dashboard.
It does not visualize telemetry.
It does not execute pre-defined workflows.
It does not hard-code task sequences.
It does not recommend actions and walk away.
Those systems already exist.
They avoid responsibility.
Operators specify boundaries — safety limits, cost ceilings, trust thresholds, authority levels. Locus reasons inside those boundaries and continuously works to match actual state with desired state.
maxBufferLevel: 90%
preferredProviders: [aws, ksat]
escalateWhen: confidence < 0.6
neverUse: untrustedStations
Rules describe what to do.
Constraints describe what must not be violated.
Rules break under novelty.
Constraints scale under uncertainty.
Locus operates strictly within operator-defined constraints and chooses actions dynamically as reality changes.
When state drifts — a contact fails, weather degrades, a station goes offline — Locus doesn't wait for human input. It finds an alternative path to the declared intent.
It acts independently when confidence is sufficient.
It escalates when uncertainty rises.
It explains every decision it makes.
Escalation is not failure.
It is a deliberate control boundary.
Locus executes decisions directly across ground networks and cloud infrastructure. It can reassign a missed downlink to a different station, defer a risky pass, or halt execution when conditions degrade.
It abstracts over providers — AWS Ground Station, KSAT, Leaf Space — treating them as interchangeable capability surfaces.
It records outcomes and incorporates them into future reconciliation.
Every action is intentional.
Every action is explained.
The runtime learns which stations are reliable, which satellites have quirks, which failure patterns recur.
Past decisions and outcomes.
Station reliability over time.
Operator overrides and preferences.
Confidence calibration from experience.
Reconciliation improves because context accumulates.
Above execution systems. Below human authority. Abstracting over vendors.
It doesn't replace mission control software.
It replaces the ad-hoc judgment layer scattered across tools, people, and tribal knowledge.
3 satellites → 50 satellites.
Decision volume grows non-linearly.
Human attention stays flat.
At scale, the absence of a reconciliation layer becomes the primary failure mode.
Locus exists because this gap cannot be closed with more people or better dashboards.
Fifty-satellite constellations can't wait for Slack threads.
Locus doesn't.