-
-
Agent Prompt
-
Agent in Action
-
Ability to Add Custom Satellite to Backend if TLE Coordinates are Correct
-
Overview Tab
-
The Wholesome Globe Animation
-
MongoDB
Project Story
🛰️ Inspiration
Space is no longer empty.
Every protected spacecraft asset exists inside a moving, crowded orbital environment. A mission operator does not only need to know where their own satellites are; they also need to know which nearby debris fragments, cataloged objects, and close approaches deserve attention right now.
For this demo, OrbitWatch acts as the mission-operations system for a fictional satellite operator. The operator has protected orbital assets and needs to monitor how close those assets come to debris and other cataloged objects in space.
The original idea came from a simple question:
What if a satellite conjunction dashboard could become an agentic review system?
Not just a map.
Not just a table.
Not just a chatbot.
OrbitWatch explores how an AI agent can inspect mission data, call backend tools, retrieve operational memory, explain risk, and help a human operator review conjunction cases with evidence.
The goal is not to replace a flight dynamics expert. The goal is to show how agents can support a real technical workflow: scan, persist, retrieve, reason, review, and keep the human in control.
🚀 What OrbitWatch Does
OrbitWatch is an agentic satellite conjunction assessment prototype.
It helps an operator:
- Register protected spacecraft assets, including custom TLE-based satellites
- Scan cataloged debris and orbital objects for close approaches
- Generate conjunction cases with miss distance, relative velocity, time to closest approach, risk score, and monitoring priority
- Visualize orbital risk inside a React + Cesium command deck
- Ask an ADK-powered agent operational questions
- Run structured agent reviews for selected conjunction cases
- Retrieve similar case memory using MongoDB Atlas and Atlas Vector Search
- Submit operator feedback on which retrieved evidence was useful
The core workflow is:
Protected orbital assets
+
Debris / cataloged objects
↓
OrbitWatch proximity scan
↓
Conjunction cases
↓
ADK agent review
↓
Operator feedback
OrbitWatch is built around the idea that risk information should not stay trapped in disconnected tables. A close approach becomes a reviewable case, a reviewable case becomes retrievable memory, and retrieved memory helps future reviews.
🤖 How It Goes Beyond Chat
OrbitWatch is not a chatbot wrapper.
The agent is connected to OrbitWatch tools and operational data. It can inspect cases, summarize active risk, review a selected conjunction, retrieve relevant memory, and expose tool traces.
Example operator prompt:
Use OrbitWatch tools to summarize the highest risk active case.
The agent responds by calling backend tools, checking live case state, and returning a grounded answer.
Another prompt:
List active assets and explain which one needs attention first based on current conjunction risk.
This is not just natural language completion. The agent needs to connect:
- Active protected assets
- Current conjunction cases
- Risk score and monitoring priority
- Miss distance and time to closest approach
- Operational recommendation
The most important workflow is the case review flow:
- The operator selects a conjunction case from the case queue.
- OrbitWatch shows the selected case readout and detailed metadata.
- The operator clicks Review with Agent.
- The ADK agent retrieves related operational memory.
- The agent produces a structured recommendation.
- The UI displays retrieved chunks and review metadata.
- The operator marks which evidence was useful.
- Feedback is stored for future retrieval improvement.
The agent does not replace the operator.
It gives the operator faster context, clearer evidence, and a traceable review path.
🧠 Agent + Retrieval Architecture
OrbitWatch combines tool use, retrieval, and human feedback.
| Layer | Role |
|---|---|
| Google ADK + Gemini | Agent reasoning, tool orchestration, and conversational review |
| OrbitWatch Tools | Controlled access to cases, assets, summaries, retrieval, and reviews |
| MongoDB Atlas | Operational persistence for assets, scans, cases, observations, chunks, runs, and feedback |
| Atlas Vector Search | Semantic retrieval over previous case memory and operational chunks |
| Vertex AI Embeddings | Embedding operational records for vector retrieval |
| FastAPI | Backend API, scan engine, persistence layer, retrieval endpoints, and agent endpoints |
| React + Cesium | Mission command deck, orbital visualization, cases UI, and agent chat |
| Cloud Run | Hosted frontend and backend services |
High-level system flow:
Operator
↓
React + Cesium Frontend
↓
Cloud Run Frontend Proxy
↓
FastAPI Backend
↓
Google ADK Agent + OrbitWatch Tools
↓
MongoDB Atlas + Atlas Vector Search
↓
Grounded answer, structured review, and feedback
The browser does not receive database credentials or privileged backend secrets. The frontend talks to the backend through a Cloud Run proxy, and protected agent/write operations are guarded behind backend controls.
🌍 MongoDB Partner Integration
MongoDB Atlas is not just used as a database in OrbitWatch. It is the operational memory layer for the agent.
OrbitWatch stores:
- Protected spacecraft assets
- Catalog snapshots
- Scan jobs
- Conjunction cases
- Case observations
- Retrieval chunks
- Agent review runs
- Operator feedback
Atlas Vector Search lets OrbitWatch retrieve similar operational chunks before the agent writes a review. This gives the agent context from actual OrbitWatch records instead of relying only on general model knowledge.
In plain English:
Operational records become memory chunks
Memory chunks become embeddings
Atlas Vector Search retrieves relevant memory
The ADK agent uses that memory to review the case
The operator gives feedback on useful evidence
That feedback loop is the important part. The agent is not just producing an answer; it is participating in a review system where retrieved evidence can be inspected and marked useful by a human.
📡 Orbital Risk Workflow
OrbitWatch uses transparent conjunction signals:
- Miss distance
- Relative velocity
- Time to closest approach
- Object type
- Protected asset maneuverability
- Monitoring priority
Conceptually:
\[ \text{risk priority} = f(d_{\text{miss}}, t_{\text{TCA}}, v_{\text{rel}}, \text{asset maneuverability}) \]
Where:
- \(d_{\text{miss}}\) = miss distance
- \(t_{\text{TCA}}\) = time to closest approach
- \(v_{\text{rel}}\) = relative velocity
OrbitWatch is a hackathon-grade prototype, not certified flight software. Real collision avoidance would require validated ephemerides, covariance modeling, uncertainty propagation, expert review, and formal maneuver authority.
But for the hackathon, this prototype demonstrates the complete agentic workflow around orbital risk:
detect risk → explain risk → retrieve memory → review case → collect feedback
🛠️ How We Built It
OrbitWatch is deployed as two Cloud Run services:
- A React + TypeScript + Cesium frontend
- A FastAPI backend for scans, persistence, retrieval, and agent workflows
The frontend is designed as a mission command deck rather than a conventional dashboard. It includes:
- Agent tab for operational questions
- Overview tab for mission state and summary telemetry
- Cases tab for conjunction case triage and agent review
- Assets tab for protected satellite management
- Orbit view for spatial context with Cesium
- Guide tab for user-facing interpretation help
The backend handles:
- Asset persistence
- Catalog scan workflows
- Conjunction case generation
- Retrieval chunk creation
- Semantic search
- Agent query endpoints
- Case review endpoints
- Feedback storage
- API-key protection and rate limiting
The agent layer uses Google ADK with OrbitWatch-specific tools. We added safer fast-path tools for common questions like highest-risk active case and active asset attention, so the agent does not need to run heavier workflows for simple operational queries.
We also added production-shaped safeguards:
- API-key protected agent and write routes
- Rate limiting for public access
- Frontend proxying so the browser does not directly hold backend credentials
- Clean timeout and quota error handling
- ADK retry safeguards for tool-level resilience
- Tool traces so the operator can see what executed
- Human feedback on retrieved chunks
⚠️ Challenges We Faced
The hardest part was making OrbitWatch behave like one coherent operational workflow instead of separate screens and APIs.
Some challenges were technical:
- Connecting orbital scan output to case review data
- Making retrieval chunks useful for actual agent reasoning
- Keeping the agent grounded in tools rather than free-form guessing
- Handling model latency, quota errors, internal errors, and timeouts cleanly
- Optimizing agent tool use so common questions did not become slow
- Protecting public endpoints from abuse without blocking the demo operator
- Keeping frontend and backend Cloud Run deployments aligned
Some challenges were product and UX related:
- Designing a mission-console interface that still works on mobile
- Making agent output feel conversational but still traceable
- Showing retrieved evidence without overwhelming the operator
- Preserving the human-in-the-loop boundary
- Making the case review workflow clear enough for a short demo video
The project became much stronger once the agent was treated as part of a workflow rather than as a chat box.
💡 What We Learned
We learned that a useful agent is not just a prompt.
A useful agent needs:
- Clean tools
- Reliable data access
- Retrieval memory
- Permission boundaries
- Traceable outputs
- Good error behavior
- A UI that makes reasoning inspectable
We also learned that public demos need production-shaped safeguards. Even for a hackathon, deployed software needs to think about API keys, rate limits, clean error messages, and what public users can trigger.
Most importantly, we learned that agentic systems are strongest when they help experts do expert work faster.
OrbitWatch does not try to hide complexity. It turns complexity into a reviewable workflow.
🔭 What’s Next
OrbitWatch is a prototype, but the direction is clear.
Next improvements could include:
- Covariance-aware conjunction assessment
- More realistic uncertainty propagation
- Scheduled scan automation
- Stronger authentication and operator roles
- Audit logs for every review and feedback action
- Better retrieval quality analytics
- Richer historical case comparison
- Notification workflows for urgent watch items
- More authoritative space situational awareness integrations
- Clearer maneuver planning support for maneuverable assets
The long-term vision is an operational assistant that helps teams move from raw orbital data to evidence-backed review.
🏁 Why It Matters
OrbitWatch demonstrates how agents can support high-stakes technical workflows without removing human judgment.
The agent helps:
- Inspect
- Retrieve
- Summarize
- Compare
- Review
- Explain
The human operator still decides what to trust and what action to take.
That is the core of OrbitWatch:
From orbital data to agent-assisted operational review.
Built With
- atlas-vector-search
- cesiumjs
- docker
- fastapi
- gemini
- googl-adk
- google-cloud-run
- mongodb-atlas
- mongodb-backed-agent-tooling
- pytest
- python
- react
- tle/orbital-propagation-concept
- typescript
- vertex-ai-embeddings
- vite
Log in or sign up for Devpost to join the conversation.