🛰️ AstraGuard AI

Autonomous Fault Detection & Recovery for CubeSats Powered by Pathway's Streaming Engine & Biologically-Inspired Memory

Explore the Project:

🌐 Live Site | 📊 Dashboard Prototype | 📚 Documentation | 🎥 Intro | 🗂️ Resources (GDrive)

📌 View Official Report

Space is unforgiving. AstraGuard makes it manageable.

AstraGuard AI is an intelligent autonomous system designed to protect CubeSats from catastrophic failure. Unlike traditional "alert-only" systems, AstraGuard uses agentic reasoning to detect anomalies in real-time streams, recall historical context using adaptive memory, and execute autonomous recovery actions—all with sub-second latency.

"Streaming anomalies. Self-updating memory. Decisions that trigger actions."

• ✅ Works on streams, not static input - Real-time telemetry processing
• ✅ Memory evolves and prunes itself - Temporal weighting with decay curves
• ✅ Agent reasons before acting - Explainable decision traces
• ✅ Actions feed back into memory - Continuous learning loop
• ✅ Dashboard outputs are structured - Validated, predictable responses

graph TD
    A["🛰️ Telemetry Stream (Pathway)"] -->|Live Data| B["📊 Embedding Encoder"]
    B -->|Vectors| C["🧠 Adaptive Memory Store"]
    C -->|Context| D["🤖 Anomaly Reasoning Agent"]
    B -->|Current Event| D
    D -->|Decision| E["⚡ Response Orchestrator"]
    E -->|Actions| F["🛰️ System Recovery"]
    F -->|Feedback| C
    
    D -.->|Reasoning Trace| G["📊 Dashboard"]
    C -.->|Memory State| G
    E -.->|Action Status| G

AstraGuard/
├── memory_engine/          # Adaptive memory with temporal weighting
├── anomaly_agent/          # Decision loop + reasoning engine
├── response_orchestrator/  # Workflow registry + action triggers
├── encoder/                # Event embedding
├── pathway_ingestion/      # Stream handlers
├── dashboard/              # Streamlit UI
├── tests/                  # Comprehensive test suite
├── examples/               # Run-ready demos
└── docs/                   # Architecture & design docs

• Python 3.9+
• pip & git

git clone https://github.com/sr-857/AstraGuard.git
cd AstraGuard
pip install -r requirements.txt

python verify_install.py

Run the demo:

python examples/run_demo.py

Launch dashboard:

streamlit run dashboard/app.py

Mission: Reactive AI agent system for live threat detection and autonomous response.

Workflow:

Live Input → Anomaly Detection → Memory Recall → Intelligent Decision → Automated Action

Key Technologies:

• Pathway Engine for streaming
• Adaptive memory with temporal weighting
• LLM-assisted reasoning
• Concrete action workflows

Mission: Biologically-inspired memory using Dragon Hatchling (BDH) architecture.

Innovation:

• Sparse neural activation
• Evolving memory (not static context)
• First-principles memory dynamics
• Continuous learning without retraining

We moved beyond static RAG to build a system that learns from the stream.

Concept: Signal reinforcement inspired by physics

Formula:

resonance = base_importance × (1 + 0.3 × log(1 + recurrence_count)) × time_decay

Impact: ~10 lines of code, demonstrates first-principles thinking

Run all tests:

pytest tests/ -v

Run specific tests:

pytest tests/test_memory_store.py -v
pytest tests/test_recurrence_scorer.py -v

Test coverage:

pytest tests/ --cov=memory_engine --cov=anomaly_agent

Core Documentation:

• 🏆 The A-to-Z Technical Master Report
• 🚀 Final Technical Report (Summary)
• 📘 Technical Documentation
• 🏗️ System Architecture & Technical Specifications
• 🌐 Website Design Specification
• 🎨 Website Redesign - Round 2 Enhanced Proposal

Additional Resources:

• 📖 Pathway Documentation
• 🐉 Dragon Hatchling (BDH) Research
• 🛠️ LLM App Framework

Edit classifier/fault_classifier.py:

• Power Threat: Voltage < 7.3V
• Thermal Threat: Temperature > 32°C
• Attitude Threat: |Gyro| > 0.05 rad/s

Edit memory_engine/memory_store.py:

• Decay Lambda: 0.1 (temporal decay rate)
• Max Capacity: 10,000 events
• Retention: 24 hours (critical events exempt)

Edit memory_engine/recurrence_scorer.py:

• Resonance Factor: 0.3 (amplification for recurrence)

• Adaptive Memory Store: Temporal weighting, auto-pruning, persistence
• Recurrence Scorer: Signal reinforcement for repeated patterns
• Decay Policy: Safe pruning with critical event protection
• Replay Engine: Security flight recorder functionality

• Decision Loop: detect → recall → reason → act → learn
• Reasoning Engine: Plain-language decision summaries
• Confidence Scorer: Decision confidence calculation

• Workflow Registry: Maps decisions to concrete actions
• Action Implementations: Real system commands (not just prints)
• Cooldown Manager: Prevents action spam

1. Fork the repository
2. Create feature branch (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push to branch (git push origin feature/amazing-feature)
5. Open Pull Request

Guidelines:

• Follow PEP 8
• Add type hints
• Include docstrings
• Write unit tests
• Update documentation

If you use AstraGuard AI in your research, please cite it using the following BibTeX:

@misc{AstraGuardAI,
  author = {Roy, Subhajit},
  title = {AstraGuard AI: Autonomous Fault Detection \& Recovery System for CubeSats},
  year = {2025},
  month = {11},
  url = {https://github.com/sr-857/AstraGuard-AI},
  note = {GitHub repository},
  license = {MIT}
}

MIT License - see LICENSE

• Pathway: Real-time streaming engine
• Streamlit: Dashboard framework
• scikit-learn: ML algorithms
• NumPy: Numerical computing
• pytest: Testing framework

Author: Subhajit Roy
Institution: Indian Institute of Technology (IIT), Madras
Hackathon: Synaptix Frontier AI Hack
Repository: https://github.com/sr-857/AstraGuard

AstraGuard AI | Protecting spacecraft through intelligent autonomy 🛰️✨