IBM AI Builders Challenge — August: Advance Space Exploration with AI
- Mission Control Dashboard: https://space-sentinel-ai.vercel.app
- Backend Telemetry API Docs: https://spacesentinel-ai.onrender.com/docs
- Demo Video: Coming soon
- Participant: Rishabh Paira
- Participation Mode: Solo Participant
Spacecraft Telemetry Simulator
→ Telemetry Processing Pipeline
→ IsolationForest + Risk Engine + Incident Classification
→ AI Mission Analyst
→ Optional IBM watsonx.ai enrichment
→ React Mission HUD Dashboard
SpaceSentinel AI — Real-Time Predictive Spacecraft Telemetry & Mission Assurance Platform
A completed prototype for monitoring spacecraft health, identifying operational anomalies, and supporting mission assurance through a live aerospace command-and-control interface.
IBM AI Builders Challenge — August: Advance Space Exploration with AI
This project focuses on practical AI-driven mission support for space exploration workflows, combining predictive telemetry analysis, anomaly detection, digital twin visualization, and lightweight operator guidance within a local challenge environment.
Mission operators need fast, trustworthy visibility into spacecraft health as sensor streams evolve in near real time. In orbit, small changes across multiple systems can compound into operational risk before a human operator can infer the pattern from isolated readings alone.
SpaceSentinel AI addresses this challenge by simulating a spacecraft telemetry environment and surfacing the current mission state through a dynamic aerospace dashboard. The platform is designed to help operators understand:
- the current health posture of the spacecraft,
- which subsystem is drifting out of tolerance,
- whether the active pattern is anomalous or nominal,
- and what recommended action may be appropriate.
The system provides mission guidance and recommended operator actions for review rather than automatically executing spacecraft recovery actions. The solution is intentionally scoped as a local simulation and operational prototype rather than a production flight-control system, aligning with the verified codebase and the challenge environment.
SpaceSentinel AI brings together a live telemetry pipeline, machine learning anomaly scoring, subsystem risk evaluation, and mission narrative analysis in a single operational experience.
The system continuously simulates spacecraft telemetry using a seven-sensor model and processes each tick through a deterministic pipeline:
- telemetry generation,
- anomaly scoring,
- risk evaluation,
- incident classification,
- UI updates for the mission dashboard and digital twin.
This architecture enables the prototype to represent a realistic mission-console workflow while remaining lightweight, explainable, and easy to run locally.
- A live backend telemetry loop advances the simulation at approximately 1 Hz.
- Sensor values are fed into the mission pipeline and rendered in the frontend UI in near real time.
- The interface includes a synchronized 3D spacecraft digital twin that reflects current telemetry state and subsystem health.
- The backend uses scikit-learn IsolationForest to detect abnormal multivariate telemetry conditions.
- The model is seeded with nominal baseline data and reset when the scenario changes.
- The contamination factor is set to 0.05, matching the current implementation configuration.
The current frontend implements a five-view aerospace operations interface:
- Mission Dashboard
- Telemetry Deep-Dive
- Anomaly Center
- AI Mission Analyst
- Incident Timeline
- The AI Mission Analyst correlates multi-sensor patterns into a structured diagnosis.
- It resolves active incident signatures such as battery stress, solar storm conditions, and subsystem degradation.
- The analysis includes
incident_type,what_happened,why_it_matters,risk_level, andrecommended_action.
- The backend exposes an optional enrichment endpoint at
POST /api/analyst/watsonx-ai. - This route is called only on demand from the analyst UI, not on every telemetry tick.
- When credentials are configured, the system can enrich the live mission diagnosis with IBM watsonx.ai output.
- The enrichment layer is intentionally isolated from the core operational loop.
- If IBM watsonx.ai is unavailable, misconfigured, or returns an invalid response, the system returns the existing heuristic analysis instead of breaking the telemetry stream.
- This preserves mission continuity and maintains operator trust during degraded AI conditions.
IBM Bob was used as the primary AI-assisted development tool throughout the planning, architecture, implementation, debugging, and refinement of the solution. It supported the work across the full life cycle of the challenge project in a practical, end-to-end development workflow.
IBM Bob helped structure the mission problem clearly, turning the raw challenge themes into a focused system objective: forecasting spacecraft health risks from telemetry signals and presenting that insight through a human-understandable operations interface.
It supported the early design process by helping refine the architecture around a live telemetry engine, detection loop, risk model, and operator-facing dashboard. This made it easier to define the product flow before implementation.
IBM Bob was used to reason through the system layout, including the division between:
- the live simulation pipeline,
- the anomaly detection engine,
- the risk assessment layer,
- the mission analyst output,
- and the optional IBM watsonx.ai enrichment path.
This helped keep the architecture modular and aligned with the verified implementation.
During implementation, IBM Bob supported iterative development tasks including:
- mapping the telemetry schema,
- designing the mission service workflow,
- clarifying the anomaly and risk logic,
- drafting backend and frontend integration patterns,
- and aligning the UI and API contract with the actual codebase.
IBM Bob was used to troubleshoot integration issues, review control flow, and validate the logic behind the optional enrichment layer and graceful fallback behavior. This was especially valuable when preserving the existing telemetry loop while introducing on-demand watsonx.ai analysis.
The final stage of the project relied on IBM Bob to refine the system narrative, tighten technical descriptions, and align the written challenge documentation with the verified behavior of the codebase. This included confirming that the solution remained honest about what was implemented and what was intentionally optional.
The implementation uses the following technologies that are present in the current verified codebase:
- FastAPI
- Uvicorn
- Python 3.11+
- Pydantic
- Scikit-Learn
- NumPy / pandas-based telemetry and anomaly processing
- IBM watsonx.ai integration (optional enrichment layer)
- React 19 (current codebase implementation)
- Vite
- TailwindCSS
- Three.js
- React Three Fiber
- Recharts
- Canvas/HUD-style mission display layer
- Axios
- IsolationForest anomaly detection
- Rule-based heuristic analyst fallback
- IBM watsonx.ai optional enrichment endpoint
cd backend
python -m venv .venv
# Windows PowerShell
.\.venv\Scripts\Activate.ps1
# macOS / Linux
# source .venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000cd frontend
npm install
npm run devIf you want to activate the optional Watsonx enrichment path, configure environment variables before starting the backend:
WATSONX_API_KEY=your_api_key
WATSONX_PROJECT_ID=your_project_id
WATSONX_URL=https://us-south.ml.cloud.ibm.com
WATSONX_MODEL_ID=ibm/granite-13b-instruct-v2The endpoint remains optional. If credentials are absent, the system will continue to operate with the rule-based heuristic analysis.
- Start the backend and confirm the API serves requests.
- Launch the frontend and confirm the aerospace dashboard renders.
- Observe telemetry updates at the live 1 Hz cadence.
- Switch scenarios and confirm the risk and anomaly view updates.
- Trigger the "⚡ Analyze with watsonx AI" action and confirm the analyst response updates without interrupting the telemetry loop.
The project was validated against the following operational scenarios and behavior patterns:
- Nominal Cruise
- Battery Failure
- Solar Storm
- Thruster Degradation / Propulsion Stress
These scenarios map to the current simulation logic and the corresponding risk/anomaly signatures used by the backend rules and mission UI.
The following behaviors are verified in the current implementation:
- Real-time telemetry continues operating at approximately 1 Hz.
- Isolation Forest detects abnormal telemetry conditions in the live simulation stream.
- Solar Storm produces a critical anomaly condition and triggers a high-severity mission response path.
- The AI Mission Analyst resolves multi-sensor signatures into a structured diagnosis.
- The "⚡ Analyze with watsonx AI" HUD action performs an on-demand enrichment without blocking the telemetry stream.
- The system uses IBM watsonx.ai when configured and gracefully falls back to heuristic analysis when unavailable or misconfigured.
- The UI remains operational even when the external AI enrichment is not available.
Status: Completed prototype and ready for IBM AI Builders Challenge submission.
This submission reflects the actual implementation in the repository and is ready for review and demonstration.