Inspiration
In a disaster, the hardest part of logistics usually isn't the routing. It's not knowing which roads are open. One report says the bridge is out, another says a truck just crossed it. Dispatchers either wait for certainty and lose time, or guess and lose deliveries.
We moved that problem somewhere it's even harder: a lunar outpost. An orbiter scan and a surface drone disagree about whether a crater pass is passable, rovers have to resupply habitats, and mission control can't verify every route at once. We asked one question:
If you can only check one route, which one actually matters?
What it does
OrbitProof is a mission-control dashboard for planning when the information is disputed.
- Gemini reads the reports. It turns messy orbiter, drone and relay messages into structured claims. Each claim must name a real route and quote the report word for word, or it is discarded.
- Conflicts are flagged. A route with both an open and a closed claim is a conflict. "Unknown" counts for neither side.
- A deterministic optimizer builds the plan. It decides which rover serves which habitat. The AI never makes this decision.
- Decision Flip Detection ranks the uncertainty. Every unverified route is solved twice, once forced open and once forced closed. If the set of served habitats changes, it's HIGH. If only travel time changes, it's LOW. If nothing changes, it's NONE.
- A human confirms, and the plan updates. Mission control verifies the route that matters, the plan recomputes instantly, and the decision is written to an audit log.
The orbiter sees the region. Mission control confirms the pass. The optimizer decides the plan.
How we built it
Engine (Python, NetworkX, SciPy). The lunar surface is a graph, and closed routes are removed before routing. Routes come from Dijkstra's algorithm on travel time. A rover can end at a habitat but never drive through one. Rovers are matched to habitats with the Hungarian algorithm (linear_sum_assignment in SciPy). The plan first minimizes priority-weighted unmet demand, then total travel time:
weighted unmet = sum over unserved habitats of (priority × demand)
cost(rover, habitat) = −1,000,000 × priority × demand
+ travel_time × (rovers × habitats + 1)
+ rover_index × habitats
+ habitat_index
The large reward term means serving important demand always beats saving minutes. The small index terms break ties, so the same input always gives the same plan, even when two routes cost exactly the same.
For Decision Flip Detection, for each uncertain route we compute:
impact = | weighted unmet (route closed) − weighted unmet (route open) |
together with how many assignments flip and how much travel time changes, then rank the routes. In our demo, closing Crater Pass strands a priority-5 habitat (impact 5, HIGH). Closing the Direct traverse only adds a 6-minute ridge detour (LOW). Rim Spur is a dead end (NONE).
Evidence (Gemini). Gemini returns structured JSON that is validated against a shared Pydantic schema. Results are cached, so every demo run is identical. A live call gets a 5-second budget, then falls back to the cache and finally to a hand-written fixture.
Backend (FastAPI). Six endpoints (scenario, plan, challenge, verify, history, reset) over an in-memory store with an append-only event log, plus an optional Tiger Data (TimescaleDB) store where events live in a hypertable and every scenario version is kept.
Frontend (React, Vite, Tailwind, Leaflet). The scenario is drawn on a generated lunar surface image, with a plain grid fallback. The dashboard shows the plan next to a nearest-rover baseline, the ranked challenge, the conflict queue with highlighted quotes, verification, and history. It also runs fully offline on fixtures generated from the real engine.
We froze the API contracts early and generated contract fixtures from the engine, so all four of us could build in parallel against the same shapes.
Challenges we ran into
- A mid-hackathon pivot. We started with a snowstorm in Buffalo on Earth imagery and moved to a lunar outpost partway through. Coordinates, names, evidence and the map all changed. Frozen contracts and generated fixtures made that survivable.
- LLM latency. Our first Gemini model sometimes took 60 to 100 seconds or returned overload errors. We added a 5-second budget with fallbacks, found that the API rejects deadlines under 10 seconds (so we enforce the cutoff ourselves), and switched to a faster model that extracts our reports in about 10 seconds with no mismatches.
- Venue networking. The Wi-Fi blocked the database port, so Tiger Data only worked over a phone hotspot. The demo defaults to the in-memory store for that reason.
- Keeping AI out of the decision. It's tempting to let the model "just decide." We built the opposite: claims are evidence only, and only a human verification can change a route's status.
- Determinism. Ties in shortest paths and assignments can make a demo flicker between runs. Explicit tie-breaking made every result reproducible.
Accomplishments that we're proud of
- An end-to-end loop that works: conflicting reports → ranked uncertainty → human verification → recomputed plan → audit log.
- Decision Flip Detection: a simple, explainable answer to "what should we check first?"
- A clear demonstration of why priority-aware planning beats "send the nearest rover." On our comparison map, nearest-rover leaves a priority-9 habitat unmet, while our optimizer serves everyone.
- 95 backend tests, frontend tests, and a demo that still runs with no network.
What we learned
- Uncertainty is only worth resolving when it would change the decision. Planning sensitivity is a practical way to measure that.
- LLMs are excellent at turning messy text into structure, and they're most trustworthy when they must cite their source and never take the final action.
- Agreeing on contracts and fixtures in the first two hours saved us many hours of integration later.
- Always have a fallback: cached claims, a grid map, offline fixtures.
What's next for OrbitProof
- Recovery Planner: when a habitat is cut off, suggest actions such as scouting another route, clearing the pass, or sending a specialised rover.
- Testing pairs of disputed routes, since two backup routes can each look harmless on their own.
- Partially passable routes (slower rather than fully open or closed) and multi-stop rover trips.
- Applying the same loop on Earth: disaster response, wildfire evacuations, and supply chains with unreliable status data.
Built With
- fastapi
- gemini
- github
- google-genai
- javascript
- json
- leaflet.js
- networkx
- numpy
- postgresql
- psycopg
- pydantic
- pytest
- python
- react
- react-leaflet
- scipy
- tailwindcss
- tiger-data
- timescaledb
- uvicorn
- vite
- vitest

