SpaceATC

Inspiration

In January 2026, SpaceX turned on Stargaze. It warns two satellite operators when they're about to collide, but it never says who should move. Both get the same alert and decide alone. Starlink already dodges a collision roughly every 90 seconds, heading toward a million maneuvers a year by 2027. Planes got air traffic control 70 years ago. Orbit still doesn't have it. That's the gap we built for.

What it does

SpaceATC is air traffic control for satellites. It pulls real orbital data for live satellites from CelesTrak, works out when two of them will pass dangerously close, and when they will, two AI agents negotiate who moves and by how much. A human approves or vetoes with one click, then the fix plays out on a live 3D globe.

The negotiation is not the hard part. The hard part is the orbital math underneath it, which is what actually decides whether the two satellites still hit each other after the maneuver.

How we built it

Everything a judge sees on the globe is driven by a real physics engine in Python, not animation. Three pieces do the real work:

1. Where is each satellite, right now? We take the public orbital data (a TLE) for each satellite and run it through SGP4, the same propagation model NASA and operators use, to get its exact position and speed in space. Then we rotate that into latitude/longitude to draw it on the globe (Earth-rotation angle via the IAU-1982 sidereal-time formula, positions placed on the WGS-84 Earth shape).

2. When and how close do they collide? We scan the next orbits and find the exact moment of closest approach, the instant the gap between the two satellites is smallest:

$$ t_{ca} = \arg\min_{t} \; \lVert \mathbf{r}_1(t) - \mathbf{r}_2(t) \rVert $$

A coarse pass every 60 seconds finds the danger window, then scipy refines it down to the second. At that moment the two objects are closing at about 14 km/s, which is why a few hundred meters of error matters.

3. What is the smallest nudge that makes them safe? This is the core. A satellite can't teleport sideways, so we use the Clohessy-Wiltshire equations, the standard math for how a small engine burn now turns into a change of position later:

$$ \Delta y(\tau) = \frac{4\sin(n\tau) - 3n\tau}{n}\,\Delta v_y $$

In plain terms: burn a little now, drift a lot by the time you arrive. We then run a binary search over burn size to find the smallest possible fuel burn (down to millimeters per second) that pushes the collision probability below one in a million. Least fuel is the whole point, because fuel is a satellite's lifespan.

Frontend: React, Three.js and satellite.js draw the globe and orbits. The AI layer runs on Groq and negotiates and explains the decision in English, but it is never allowed to touch the numbers, a deterministic guardrail owns the physics.

Challenges we ran into

Keeping the AI honest. Language models explain well and calculate badly. So the AI narrates the deal while the math engine owns every number.
Real data is messy. Live orbital feeds have gaps and stale entries, so we filtered hard to make sure every satellite on screen is a real object.
Making orbital mechanics readable in three minutes. The hardest part wasn't the physics, it was translating it so anyone gets it at a glance.

Accomplishments that we're proud of

A full loop on real data and real physics: live orbits, a real predicted collision an AI negotiation, and a human approval, all on a 3D globe. It runs on a laptop anddemos live, nothing staged or pre-recorded.

What we learned

Coordination, not detection, is the unsolved problem in orbit. Everyone can see the collision coming. Nobody agrees on who moves. We also learned where AI belongs in a safety system: as the negotiator and explainer, never as the calculator.

What's next for SpaceATC

Negotiations across more than two operators at once, real Conjunction Data Message inguncertainty (covariance) so the collision probability uses each operator's real tracking error instead of a fixed estimate.