Flight Routing Lab

For engineers

The reward, how lookahead plans, the environment's rules, Gatebound's pipeline, what this rebuild leaves out, and how to reproduce the run.

The reward

The reward is terminal, paid once when the trip ends:

R = 0.80 × on time
  + 0.10 × arrived
  + 0.10 × arrived
    × (horizon − arrival) / horizon

The horizon, 16:00, is where the simulated day ends. The first nonstop, F3, landing on schedule at 08:00 earns 0.95; the same flight landing at 11:00, past the 09:00 deadline, earns 0.13125; a cancellation earns nothing.

How lookahead plans

Lookahead plans on the model, never on the sampled outcome. For each bookable flight it runs through the ten joint outcomes in that flight's pool and recurses to the end of the trip. Under the mixed profile the first nonstop's modelled chance of arriving by 09:00 is 80%, and by 07:55 0%; the Denver connection's are 64% and 64%. These are probabilities under this fixture, not forecasts. More lookahead is not a general win; it is a different trade, and the reward decides when the trade is worth taking.

Like Gatebound's planner, it maximizes only the chance of making the deadline and breaks a tie by the earliest scheduled arrival, then the first listed flight. So when no flight can make the deadline, every choice ties at zero and it books the earliest arrival, which can be a dead end: set an unreachable deadline under the hood and lookahead strands the passenger as greedy does.

The environment

A deadline-aware routing environment with masked actions, joint disruption samples and paired policy evaluation, each of which the paragraphs below spell out.

State and actions. The state is the passenger's airport, clock and attempts so far. The actions are the flights leaving that airport at least the connection buffer after the clock and before the horizon, in a fixed order, padded to eight slots with a binary mask, so a policy can never pick a flight that has already left.

Joint outcomes. Taking a flight reveals one whole outcome row: departure delay, arrival delay, cancellation and diversion together, never sampled field by field, so the simulator cannot invent a cancellation plus an unrelated delay. A cancellation keeps the passenger at the origin. An unresolved diversion ends the trip without moving them to an airport they never confirmed. After a landing, the next action set is built from the actual landing time, not the scheduled one.

Paired worlds. The outcome row is picked by hashing the world's seed with the flight, so a flight has the same outcome in a world whichever policy reaches it and whenever. Comparing policies on shared worlds takes sampling noise out of the comparison, and it makes a rewind in the replay a true counterfactual: the other branch of the same day.

Terminal reasons. Arrived, cancelled, diverted, no onward flight, out of attempts and out of time are kept apart. A stranded passenger and a cancelled one both score zero; the run still tells them apart.

Gatebound’s pipeline

Gatebound ingests monthly US flight-performance archives into partitioned Parquet, builds comparable-flight outcome pools, runs masked Gymnasium environments with a deadline planner and a masked REINFORCE learner, and checks every episode record against its configured schedules and outcome rows, so a forged but plausible record cannot earn reward.

What is left out

Six invented flights, ten joint outcome rows a flight and two mirrored networks. Chicago is a deliberate dead end, and the return route mirrors the outbound one rather than pretending to be a second dataset. The clear and stress profiles are controlled edits, not weather models, and times are minutes from midnight, not local clocks.

Left out next to Gatebound: prebooked itineraries, rebooking after a cancellation, fares, carriers, time zones, historical pool fitting, record authentication and the learned policies. Nothing here is a passenger-benefit estimate or a training result. The outcome hash is FNV-1a with an avalanche step, not Gatebound's cryptographic generator, so seeds do not carry across; and the outcomes ship with the page, so hiding them in the interface is not a security boundary.

Reproduce it

The engine, fixtures and reference cases are in the code for this page. 10 reference cases pin terminal paths (on time, late, cancelled, diverted, stranded, out of attempts, out of time, an invalid action) to exact clocks and rewards, and a test recomputes the 64-world run and compares it with the committed JSON. From the site's Next.js app:

npx vitest run src/lib/projects/flight-routing

Export, under the hood in the replay, writes the trip with its configuration, fixture version, outcome rows, reward terms and the 64-world comparison, so a run can be checked outside the page.