ARIA Space Rider Mission Control

A real-time copilot for ESA’s Space Rider parafoil landings, powered by GPT-OSS-20B: streams telemetry, retrieves procedures + past lessons, proposes vetted next actions with human in the loop.

Comment

Inspiration

ESA’s Space Rider will autonomously re-enter and land under parafoil - an edge case where local, reliable AI can help flight controllers reason over fast-changing telemetry. We wanted to show that open models (GPT-OSS-20B) plus careful context engineering can deliver mission-grade decision support: private, auditable, and resilient during comms gaps.

What it does

ARIA Space Rider Mission Control is a real-time copilot that:

  • Streams telemetry (20 Hz), detects simple anomalies, and plans at 1 Hz.
  • Uses RAG over Space Rider procedures and cross-mission “lessons” distilled from prior runs.
  • Produces a schema-checked JSON plan (action, rationale, risk, confidence, checks).
  • Passes plans through a Safety Gate (redlines + confidence fusion) before showing them.
  • Keeps a human in the loop (Approve / Modify / Reject), with live gauges, timeline, and a chat panel.
  • Runs fully local with GPT-OSS-20B (Groq or CPU/GPU), logging everything to SQLite for audit.

How we built it

Backend (FastAPI + SSE)

  • services/playback.py: CSV -> 20 Hz ticks, 1 Hz planner, SSE events.
  • services/planner.py: token-budgeted working memory (state + episodic + docs + lessons) -> GPT-OSS-20B -> Plan schema -> Safety Gate -> episodic log.
  • Memory fabric (aria/memory): SQLite + FTS5 for docs, rephrased cards (facts/QA/lessons), episodic log, and semantic lessons; retrieval reranks with embeddings.
  • Governor trims and prioritizes context within a strict token budget.
  • Distiller converts episodic logs into durable lessons after each run.

Frontend (Next.js + Tailwind v3 + AI SDK 5)

  • Live SSE client for ticks/plans/anomalies/metrics.
  • Components: Gauges, PlanPanel, Timeline, and Chat (Vercel AI SDK 5, Groq backend).
  • Dark/light theming, compact layout to fit without scroll during demos.

Challenges we ran into

  • SSE robustness: one-consumer queue dropped events; replaced with a fan-out bus (per-client queue + pump task).
  • Retriever edge cases: blobs missing embeddings (None) and FTS joins; fixed with safe decoding + hybrid lexical/semantic rerank.
  • Governor mismatches: section key drift (“docs” missing) causing KeyErrors - normalized with canonical section set.

Accomplishments that we're proud of

  • End-to-end local agent: GPT-OSS-20B + retrieval + safety gate + UI, all offline-capable.
  • Schema-aligned planning with plan/risk normalization and post-gate re-validation.
  • Learning across missions: episodic to semantic lesson distillation, automatically reused in later runs.
  • Clean, auditable SSE timeline of ticks, anomalies, plans, and human decisions.

What we learned

  • Context > parameters: a well-governed prompt with the right slices of memory beats raw model size.
  • Safety needs structure: JSON plans + rule checks + confidence fusion make human review faster.
  • SSE in production: fan-out queues and heartbeats are mandatory for stable realtime UX.

What's next for ARIA Space Rider Mission Control

  • Richer detectors: phase/anomaly models (bank limits, flare window) feeding the planner.
  • Tool-augmented ReAct: let the model request doc_search()/recall_lesson() mid-turn when uncertain.
  • Evaluation harness: replay suites with success metrics (touchdown Vz, lateral error) and ablation dashboards.
  • Observability: Langfuse/OpenTelemetry traces for retrieval, tokens, and safety interventions.
  • Edge deployments: packaged images for on-prem GPU and Groq LPU; smaller OSS variants for CPU.
  • Human factors: rationale summaries for controllers, plus optional voice narration for debriefs.

Built With

Share this project:

Updates