Inspiration

Methane is a powerful greenhouse gas, and satellites are one of the best ways to spot leaks from oil and gas sites. But a satellite only gets a few chances to look at any one site. It has to be overhead, in daylight, at a good viewing angle, without clouds, and with enough battery and storage left. Some leaks also come and go.

That raised a simple question: if you only get a handful of looks, how should you decide where to point next?

What it does

AETHER is a flight simulator for satellite scheduling. It runs a simulated mission over 20 methane sites in the Permian Basin (Texas and New Mexico), lets different planning strategies choose which sites to observe, and grades each strategy against a hidden answer key.

Each round, the planner:

Finds when each site is visible, based on orbit, daylight and viewing angle
Scores each possible look by how much it would teach the planner
Builds a schedule that fits battery, storage and timing limits
Simulates the look, where the hidden answer key decides what the satellite "sees", including missed detections and false alarms
Updates its guesses about how likely each site is to be leaking
Replans when new evidence or a forecast change comes in

After the last round, each strategy's guesses are compared with the answer key.

The strategies

adaptive_eig (the main one): keeps re-ranking sites by expected information gain and builds an optimized schedule
greedy_eig: same scoring, but picks one look at a time instead of optimizing the whole schedule
largest_first, static_priority, first_feasible: simpler baselines
random: the lower bar
oracle: can see the answer key; the upper bar, used for comparison only

What's real and what's simulated

Real: 20 historical methane plume sightings from NASA's EMIT instrument on the International Space Station, used only to place the sites
Simulated: the satellite, the sensor, the weather, and which sites are actually leaking

AETHER is a research prototype. It does not control real satellites, detect real leaks, or verify emission reductions.

How we built it

Data ingestion: Parses NASA EMIT L2B CH4PLM V002 plume records and keeps their provenance. Input files are hashed so every run can be traced to the exact data used. Missing emission rates (10 of the 20 records) stay missing instead of being treated as zero.
Orbits and visibility: SGP4 and Skyfield, with pinned ephemeris and Earth-orientation data, compute when each site can be observed and why a look gets rejected.
Sensor model: Detection probability depends on emission rate, ground sampling distance and wind. The model also includes false positives and measurement uncertainty.
Beliefs: Each source's hidden activity is a mixture of three regimes, each a two-state Markov process. The planner tracks a probability distribution over source state and emission rate, and it updates using estimated wind, never the true wind.
Planning: Expected information gain feeds Google OR-Tools CP-SAT. The solver enforces one option per observation window, no overlap or slew conflicts, per-source visit limits, per-orbit limits, and storage and energy budgets.
Independent checker: Re-checks every schedule with its own geometry and logic, without calling the planner's optimizer.
Evaluation: Brier score, calibration, high-impact-source recall and corroboration timing, using paired seeds and bootstrap confidence intervals.
Frontend: A read-only console over saved runs, plans, beliefs and comparisons.

We also enforced a few ground rules throughout:

The planner never sees the hidden truth. Only the simulator and the evaluator can.
"Couldn't see" is never treated as "no leak".
All randomness comes from one seed, so every run can be replayed exactly.
Times are UTC-aware, and units are in variable names (kg_h, m_s).

Challenges we ran into

The scenario is too cramped. The test scenario has 7 satellite passes in 72 hours, which meets the pass-count target. But one pass can only see 2 sites, and the benchmark needs at least 4. No scheduling algorithm can observe what isn't visible. A longer time window met the targets on one test seed, but we haven't adopted it without more evidence.
The test couldn't tell good from bad. In development runs, the oracle (which sees the answers) and the random strategy didn't separate enough. Until they do, ranking the real strategies wouldn't be fair, so we flagged it instead of declaring a winner.
Keeping real and simulated data apart. Real observations, simulated observations and the hidden truth needed separate identities, and that separation had to hold in every layer of the system.

Accomplishments that we're proud of

The full pipeline runs end to end, and every run is reproducible from a single seed.
The independent checker found zero rule violations in the runs we checked.
The demo shows the planner revising its plan when a scripted cloud and forecast event hits.
The system caught its own weak benchmark before we could make a misleading claim.

What we learned

A benchmark first has to show it can tell an oracle from a coin flip. Only then can it rank anything else.
Orbit geometry sets a hard ceiling: smarter scheduling can't beat what is physically visible.
"We didn't see it" and "it isn't there" are different, and mixing them up quietly biases results.
Two runs are not evidence. In a small two-seed trial, adaptive_eig actually scored worse than largest_first, and that's far too few runs to conclude anything either way.

What's next for AETHER

Fix the scenario's capacity, for example by deciding on a longer time window with more supporting evidence
Adjust the scenario until the oracle and random strategies clearly separate
Resolve the mixed calibration results
Lock the evaluation protocol and run the holdout benchmark
Only then compare adaptive_eig against the baselines for real