Cyclone response through the real 2026 Andhra-Odisha storms
Demo bpHigh/CycloneSim, read from Hugging Face 1 min ago.
bpHigh/CycloneSim is a live demo on Hugging Face by bpHigh. Cyclone response through the real 2026 Andhra-Odisha storms. It declares the mit license on Hugging Face. It has 1 likes and last changed on 2026-11-20. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from Hugging Face on 2026-11-21.
The author's own card, shown from Hugging Face. Take My Repo does not keep a copy.
Run cyclone response on the Andhra Pradesh and south Odisha coast through the two cyclones that struck it back to back in October-November 2026, rebuilt from IMD's own bulletins, JTWC's storm sizes and ERA5 rain. The goal is the one a state emergency operations centre has: the fewest deaths and the least harm to people and property. The levers are when and where to evacuate, where the NDRF/SDRF rescue teams wait and when they drive, and where the power restoration gangs go. Every plan is graded against the exact optimum of a linear program.
Online: huggingface.co/spaces/bpHigh/CycloneSim: the 3D twin with every plan, the eval boards, the storm in progress and a plain-language guide to the metrics (a static export, tools/export_static.py; tools/deploy_space.py publishes it).
Video (20 s): assets/cyclonesim-storms.mp4: Arnab and Murasu replayed with the best response, then Akvan's forecast (tools/video/make_video.sh).

| Arnab (BOB/08/2026) | Murasu (BOB/09/2026) | |
|---|---|---|
| IMD bulletins | 34 (24-29 Oct) | 29 (31 Oct-4 Nov) |
| Peak (IMD analysis) | very severe cyclonic storm, 150-160 km/h | severe cyclonic storm, 100-110 km/h |
| Landfall | 02:00-08:00 IST 28 Oct, 20 km east-northeast of Narsapur (16.45N 81.90E), 125-135 gusting 150 km/h | 03:30-05:30 IST 3 Nov, near Ongole (15.53N 80.22E), 100-110 gusting 120 km/h |
| IMD surge warning | 1.5-2.5 m | 1.0-1.5 m |
| Record | 57,000-89,000 evacuated in Andhra Pradesh; 16 NDRF + 11 SDRF teams before landfall, 39 + 80 after; about 70,900 ha of paddy lost | 13 NDRF teams in Andhra Pradesh; 160,000 evacuated in Odisha |
The second storm arrived four days after the first: shelters, stranded people and outages from Arnab were still on the books when Murasu's first bulletin came out, and its track ran south of Arnab's, onto different districts.
Plan mode (hindsight). The agent knows the whole window's weather and submits one plan. Tools: get_situation,
get_district, check_plan (10 per episode, never a score), submit_plan (graded once).
Live mode. Every 6 hours the agent sees only what IMD had issued by then: the latest bulletin's forecast table
and surge warning, the hazards that forecast implies for each district, and the state of the coast (people in shelters,
stranded, homes without power, every team and crew). It commits orders, and 6 hours of the real weather play out. A
storm appears only when IMD's first bulletin on it does. Tools: get_status, get_forecast, check_orders, commit.
The executed orders are graded on the truth against the same optimum, so live and plan scores are comparable.
IMD's forecasts are good on track but the timing matters: until the day before, every bulletin put Kakinada's gale 6-9 hours later than it came, and moving 34,000 people takes 12 hours. A planner that trusts the forecast and evacuates just in time is caught by the gale (see the live baselines below).
tools/fetch_bulletins.py IMD national bulletins (59 PDFs) -> data/imd/forecasts.csv, bulletins.json
tools/curate_region.py 26 districts: geoBoundaries + published areas/populations + OSM headquarters
tools/curate_ibtracs.py IBTrACS (JTWC) radius of maximum wind
tools/curate_era5_grid.py ERA5 hourly rain on a 0.25 degree grid (Open-Meteo archive)
cyclone_core.hazard wind (modified Rankine + forward speed), surge (fitted to IMD's warnings), rain (ERA5,
moved with each forecast's position error) per district and 3-h step
cyclone_core.task windows (arnab, murasu, twin) x start (early, late) x resources (lean, standard, surge)
cyclone_core.sim parse_plan, simulate, price: the grader (pure Python, deterministic)
cyclone_core.solve the grader as an LP (HiGHS); its optimum is re-run through the grader and must match
cyclone_core.baselines hold, rule (standard procedure with hindsight)
cyclone_core.reward rho = (cost - opt)/(sop - opt); 0.2 + 0.8 exp(-rho/0.25); infeasible 0.19 x clean share
cyclone_core.live LiveEpisode: bulletins as issued, 6-h commits, policies (sop, mpc, ensemble, hold)
cyclone_core.feed live data: active cyclones from GDACS (JTWC tracks) or any new IMD bulletin -> hazards
and the optimal plan if that track is right
cyclone_core.replay any plan on the true weather, step by step (the twin's data)
cyclone_env tool sessions, an OpenEnv MCP environment and server, an OpenAI-compatible agent loop
web/twin the 3D replay (three.js)
eval/run_eval.py rollouts and boards: results/rollouts/<run>/
Everything is priced in life-equivalents (LE); one expected death is 1 LE:
| LE | |
|---|---|
| expected death (at home or stranded) | 1 |
| stranded person, per 3 h, beyond the death hazard | 0.00005 |
| person in a shelter, per 3 h | 0.00001 |
| person moved out / home | 0.0001 / 0.00005 |
| home without power, per 3 h | 0.000002 |
| team or crew, per km driven | 0.00002 |
Evacuating too early, too widely or for too long costs real harm (lost work, crowded camps, disease); too late or too little costs lives. The board reports expected deaths separately from the total.
rho = (cost - optimum) / (reference - optimum) 0 at the optimum, 1 at the reference
reward = 0.2 + 0.8 exp(-rho / 0.25) infeasible plans: 0.19 x share of moves that broke no rule
Plan mode's reference is the standard procedure with hindsight (evacuate every district from 24 h before its gale, home 12 h after; send teams and crews at once in proportion to need), not doing nothing: doing nothing through Arnab costs about a thousand expected lives, so any evacuation at all would look good against it. Live mode's reference is doing nothing: with only the bulletins issued so far, even the best live policy costs 3-5 times the hindsight optimum, and the hindsight procedure is not something anyone can run live. Both modes use the same hindsight optimum, so a live score says how much of the avoidable harm was avoided with the information IMD had.
All 24 tasks (tasks/cyclone-v1: 3 windows x early/late start x lean/standard/surge resources, plus 6 lean variants
with the units' bases shuffled). Expected deaths are means per task. Boards: results/rollouts/baselines-plan/board.md,
results/rollouts/baselines-live/board.md.
Plan mode (hindsight)
| mean reward | expected deaths, Arnab early / late | Murasu early / late | both storms early / late | people evacuated, Arnab early | |
|---|---|---|---|---|---|
| exact optimum | 1.000 | 46 / 282 | 6.7 / 10.8 | 53 / 289 | 89,079 |
| standard procedure (hindsight) | 0.215 | 59 / 295 | 7.2 / 11.3 | 79 / 315 | 116,137 |
| do nothing | 0.200 | 1,131 / 1,128 | 88 / 88 | 1,224 / 1,224 | 0 |
The optimum evacuates about as many people before Arnab (89,079) as Andhra Pradesh reported (57,000-89,000), though nothing in the model was fitted to that number. A late start (9 h before the first coastal gale) leaves no way to save everyone: moving 34,000 people out of Kakinada takes 12 h.
Live mode (only the bulletins issued so far; reward against doing nothing)
| policy | mean reward | expected deaths, Arnab early | Murasu early | both storms early |
|---|---|---|---|---|
| exact optimum on 6 forecast scenarios (IMD's forecast moved by the other storm's real errors) | 0.681 | 286 | 7.8 | 294 |
| standard procedure on the latest bulletin (evacuate when a gale is forecast within 24 h) | 0.555 | 358 | 27.8 | 388 |
| exact optimum on the latest bulletin, trusting it | 0.286 | 763 | 35.9 | 798 |
| do nothing | 0.215 | 1,131 | 88 | 1,224 |
| hindsight optimum (for scale) | 1.000 | 46 | 6.7 | 53 |
Why live is hard. IMD's track errors over the two storms averaged 51 km at 12 h, 82 km at 24 h and about 100 km at 36-48 h for Arnab (28, 53, 75-98 km for Murasu), and both storms came in a little stronger than forecast. The costly error was timing: until the day before landfall every bulletin put the gale on Kakinada and Konaseema 6-9 h later than it came. A perfect optimiser that trusts the bulletin evacuates just in time and is caught: it does worse than the plain procedure. Hedging over forecast scenarios built from real forecast errors recovers much of the gap, but even it loses six times as many lives to Arnab as hindsight would. That gap is what live mode measures.
No language model has been run yet. eval/run_eval.py --model hf:<model> (or openrouter:, openai:,
local:<model>@<url>) runs one in either mode and records tokens and time.
python -m cyclone_core.feed lists the cyclones active in the North Indian Ocean now (GDACS, which republishes JTWC's
track every 6 h). --event <id> turns one into hazards for the 26 districts and the plan that is optimal if its track
is right; --imd <bulletin PDF URL> does the same from an IMD national bulletin (better: the official track and
winds). There is no rain field for a storm that has not happened, so the feed's hazards are wind and surge only. On
Murasu's GDACS record it puts the worst surge on Bapatla and Prakasam, as IMD did.
The server (uvicorn cyclone_env.server:app) serves the OpenEnv API and the twin at /twin/, which replays any
plan (the optimum, the procedure, the live policies, a model's run) on the true weather:
?task=&plan=&t=&cam=&metric=&sat=1&sel=KON&play=1.![]() |
![]() |
![]() |
![]() |

tools/build_scene.py rebuilds the twin's assets (web/twin/assets/, 6.4 MB) from their sources.
A third cyclone, Akvan, formed in the Bay of Bengal on 15 November 2026. IMD's bulletin 18 (17 Nov, 20:30 IST) forecasts it to cross the Andhra Pradesh coast between Nellore and Visakhapatnam around noon on 20 November as a very severe cyclonic storm (120-130 km/h gusting 145), close to the Godavari delta that Arnab struck three weeks earlier.
tools/watch_storm.py runs every 6 hours while Akvan is active. It adds each new IMD bulletin, saves GDACS's JTWC
track, and recomputes the coastal hazards and the optimal plan on IMD's latest forecast. Each run also saves what
AWARE's public pages show (tools/aware_snapshot.py: ECMWF strike probability and forecast wind per district, the
INCOIS storm-surge page); public pages only, as any visitor sees them. Everything lands in data/live/akvan/
(log.md has one line per check). When IMD stops tracking the storm and ERA5 has caught up (about 5 days),
tools/finish_storm.py builds Akvan's tasks (early and late starts x three resource tiers) and reruns the baselines.
cd cyclonesim
uv venv -p 3.13 .venv && uv pip install --python .venv/bin/python -e ".[server,agents,curate,dev]"
.venv/bin/python -m pytest -q
.venv/bin/python -m cyclone_core.pack --out tasks/cyclone-v1 # 24 tasks with their optima
CYCLONE_MODE=plan .venv/bin/uvicorn cyclone_env.server:app --port 8000 # then open /twin/
.venv/bin/python eval/run_eval.py --baselines --mode live # live baselines
.venv/bin/python eval/run_eval.py --model hf:<model> --mode live --tasks 3 # a model, live
.venv/bin/python -m cyclone_core.feed # cyclones active now (GDACS)
Rebuilding the data from the sources: tools/fetch_bulletins.py, tools/curate_ibtracs.py, tools/curate_region.py,
tools/curate_era5.py, tools/curate_era5_grid.py (in that order). data/SOURCE.md says, for every number, whether
it is real, derived or assumed.
bpHigh/CycloneSim is a live demo on Hugging Face by bpHigh. Cyclone response through the real 2026 Andhra-Odisha storms.
It declares the mit license on Hugging Face.
No. It is a live demo that runs in the browser on Hugging Face.
Its last change on Hugging Face was on 2026-11-20. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.

Train open models with RL inside real agent harnesses
Runs in the browser on Hugging Face

Real-world simulation RL environments for AI agents
Runs in the browser on Hugging Face
From an idea to a trained 4B, with the dead ends left in
Runs in the browser on Hugging Face
Dispatch trains on a real single-track Dutch line
Runs in the browser on Hugging Face
Text classification model, used with transformers.
Run the Army Corps' Cumberland dams through real 2025 floods
Runs in the browser on Hugging Face

A small model learns to dispatch real Dutch trains
Runs in the browser on Hugging Face