Shortlist: which open RL environments can a model learn from?

OpenEnv's RFC 008 reserves the statistical learnability checks for whoever runs a validation hub, and ships no runner for them. Shortlist is that runner. Beam plays each environment at every rung of a capability ladder: doing nothing, acting at random, a small model, then Beam itself from low to max reasoning effort. Where the rungs spread out, a model can learn; where they pile up, it can't. The checks turn that into a verdict per environment, and a GRPO training run tests whether the verdicts hold.

Results page: https://huggingface.co/spaces/JagritGumber/shortlist. This repo holds the data, the code and the training proof behind it.

At a glance

• 32 environments, 47 task suites, 1,177 episodes: 640 played by Beam (1,572,150 output tokens), 240 by the small model (Qwen3-0.6B), the rest by the two model-free players.
• Verdicts predict where reward moves, not whether the skill is learned. 6 of 6 pre-registered predictions held when Qwen3-0.6B was trained with GRPO. But in 4 of the 5 families where reward rose, the model got there by gaming the grader or learning the answer format, not the skill. Beam's blind audit matched our reading on four families, caught the word-sorting echo before we did, and was stricter on basic arithmetic.
• So the shortlist now checks whether a reward can be gamed. 5 of 10 Reasoning Gym families pay more for an answer that needs no skill than the small model earns now, including two the training run didn't cover: maze (always "5" scores 0.315) and game of life (an empty board scores 0.962). This check was added after training. Maze was then a forward test, published before training: it collapsed with no skill, as predicted (3 of 4 claims held), but onto a different cheat than the one we named.
• Three defects in shipped environments, each flagged by Beam's play on the ladder: Connect 4 (no opponent; Beam diagnosed it and wrote the fix), DIPG (its answer markers are Beam's own control tokens), Pelican (the vision judge is off by default, so any two-wheeled drawing scores 1.0).
• Effort is a ladder too. On 12 suites, Beam's highest effort solved more tasks than low effort on 8, as many on 3, and fewer on 1.
• Hub census. Of 269 OpenEnv Spaces checked, 63 (23.4%) run and pass the floor checks; 13 pay 1 or more for doing nothing.

How Beam is used

Beam (Beam-1.0-501B-A23B, through Reflection's OpenAI-compatible API) does five jobs. Each is a script in code/, and every output it produced is in this repo.

1. Plays the top rungs of the ladder. Beam acts through one tool built from the environment's own action schema, after reading the environment's README, at low, medium, high or max reasoning effort. Its rungs are the reference that shows a task can be done. 640 episodes, 1,572,150 output tokens. (code/shortlist/policies.py, code/scripts/ladder.py, episodes.jsonl)
2. Diagnoses and fixes broken environments. When a check fails, Beam gets the ladder's numbers and the environment's source, explains the failure and writes the patch. For Connect 4 it found there was no opponent: as shipped, doing nothing won 3 of 3, random play 9 of 9 and Beam 9 of 9. On Beam's fixed copy, doing nothing won 0 of 3, random play 1 of 9 and Beam 8 of 9. (code/scripts/fix.py, fixes/)
3. Writes setups for environments it has never seen. For 20 Hub environments, Beam read the README, the action schema and the first observation, and wrote the setup Shortlist plays: episode length, how to score, what counts as solved and the maximum reward, each backed by a quote from the README. (code/scripts/setup_env.py, census/setups/)
4. Gives a ladder of skill inside one model. Its effort settings let one model fill several rungs, so difficulty separation can be measured without a zoo of models. (effort in the results page data)
5. Audits the training run. Given each grader's source, one question, and a few answers from before and after training, but not our conclusions, Beam (high effort) judged whether the model learned the skill, the format, or a loophole. (code/training/audit_with_beam.py, training/beam_audit.json)

One finding is about Beam itself: DIPG only scores answers wrapped in <|channel|>analysis<|message|> … <|end|>, which are single control tokens in Beam's Harmony-style chat format. When Beam writes them inside an answer they arrive mangled, so every answer took the −10 format penalty (0 of 12 cleared the format check). With square-bracket markers, a setting DIPG already has, 7 of 12 cleared it.

The ladder and the checks

Rung	Player
Does nothing	Always takes the first allowed action. No model.
Acts at random	Picks a random valid action. No model.
Small model	Qwen3-0.6B, thinking off, served by llama.cpp (Q8_0). Reasoning Gym only: the model you would train.
Beam, low → max	Beam-1.0-501B-A23B at each reasoning effort.

The checks, in code/shortlist/checks.py:

• Floor gap (semantic.floor_gap): doing nothing or acting at random must not already earn the top reward.
• Reward reachability: the strongest rung earns reward.
• Difficulty separation: the strongest rung beats the floor (one-sided bootstrap, p ≤ 0.05).
• Headroom: the best rung leaves room below the known maximum.
• Variance: replaying one task varies less than the strongest rung's gain over the floor.
• Adversarial floor (RFC 008 #26, Reasoning Gym only, added after training): no answer that needs no skill pays more than the learner earns now and at least a tenth of the top reward. The RFC leaves the procedure open; ours (code/shortlist/gaming.py) tries a constant answer, the question echoed back, and the task's input played back.
• GRPO signal: the learner's repeated attempts at one task disagree on at least one task in five. Those are the only tasks a GRPO update learns from.
• For the small model (code/shortlist/trainee.py): worth training if its mean reward is above zero, it solves under 95% on the first try, and its GRPO signal is at least 20%.

Verdicts are judged for the small model where it played (Reasoning Gym), and for Beam everywhere else.

Results

The shortlist

For the small model (Qwen3-0.6B)

Verdict	Count	Environments
Worth training on	8	Basic arithmetic, Chain sum, Countdown, Letter counting †, Maze †, Propositional logic †, Sudoku, Word sorting †
Too hard for the small model now	2	Game of life †, Leg counting

For Beam (no small model played these)

Verdict	Count	Environments
Worth training on	11	Connect 4, with Beam's fix *, Fraud triage *, Boobesh007/code-review (Hub) *, anugrahteesdollar/drugenv (Hub) *, sergiopaniego/repl (Hub) *, sergiopaniego/wordle (Hub) *, souller/email-triage-env (Hub) *, yaswanth169/data-janitor-env (Hub) *, Snake *, Sophistry bench, Wildfire *
No gradient	4	Grid world *, TejasS1233/openenv-food-delivery-dispatch (Hub) *, creovateHQ/BrowserForge (Hub) *, mykrex/webyx-env (Hub) *
Too easy for Beam	1	Maze (maze_env) *
Skill doesn't show yet	2	Blackjack *, Catch *
Weak signal	3	openenv/coding_env (Hub) *, Cliff walking *, Tic-tac-toe *
Out of reach for Beam	8	Chess *, Bb-03/os_expert_env (Hub) *, FineEnvs/nayana-ocr-env (Hub) *, RavichandraNayakar/customer_support_env (Hub) *, Vivaan13/smartinbox-pro (Hub) *, openenv/openspiel_env (Hub) *, 2048 *, Kuhn poker *
Flat reward	4	FineEnvs/geoguesser-env (Hub) *, openenv/atari_env (Hub) *, openenv/echo_env (Hub) *, yaswanth169/APISHIFT (Hub) *

Broken as shipped (4): Connect 4: doing nothing already earns the top reward; DIPG medical safety: its default answer markers are chat-control tokens for Harmony-format models such as Beam, so no answer clears the format gate; adishu/auto_jailbreak (Hub): most episodes error; Pelican on a bicycle (SVG): the vision judge is off by default, so the reward checks only shapes and any two-wheeled drawing scores 1.00.

* provisional: fewer than 4 tasks, so a first pass rather than a final call. † can be gamed: a no-skill answer pays more than the small model earns now (see below; added after training).

Per-suite numbers, every check and its statistics are in verdicts.json.

Does the verdict predict training?

The predictions for 6 small-model families were written first. Their SHA-256, d11a5928bce2f1b045b593e699370612779b6b45950cbdbee256ef6a23ccc776, was committed to this repo at 2026-10-30 16:23:45 UTC; the first training checkpoint is from 2026-10-30 16:25 UTC. Qwen3-0.6B was then trained with GRPO for 100 steps per family (TRL, LoRA r=16, fp32, one Kaggle T4) and scored on the same 200 held-out tasks before and after.

Family	Predicted	Mean reward before → after (p)	Accuracy before → after	What the model learned	Beam's blind audit
basic_arithmetic	reward rises ✓	0.052 → 0.483 (<0.001)	1% → 48%	Partly skill, partly format. Read leniently, the untrained model was already right on 25.5%.	learned the format
chain_sum	reward rises ✓	0.038 → 0.300 (<0.001)	0.5% → 23%	Mostly format. Read leniently, the untrained model was already right on 40%.	learned the format
letter_counting	reward rises ✓	0.137 → 0.350 (<0.001)	13.5% → 35%	Gamed the grader. It answers "1" to everything; that alone scores 0.350.	gamed the grader
propositional_logic	reward rises ✓	0.001 → 0.993 (<0.001)	0% → 99%	Gamed the grader. It joins the premises with "and"; that alone scores 0.993.	gamed the grader
word_sorting	reward rises ✓	0.221 → 0.253 (0.008)	1% → 2%	No real gain. Repeating the input words unsorted already scores 0.256.	gamed the grader
leg_counting	no change ✓	0.000 → 0.000 (0.653)	0% → 0%	No change. No reward on any attempt, so nothing to learn from; this prediction could not fail.	no change

The pre-registered criterion, "reward rises", held for all 6. What moved reward was mostly a cheaper route the grader allows: a constant answer, the input played back, or a change of format. The do-nothing and random players can't see those routes, because each needs one specific answer, so a training run needs a second check once it finishes. Beam can run it. Its audit called letter counting and propositional logic gamed, chain sum a format gain, and leg counting unchanged, as we did. It caught the word-sorting echo before we did. On basic arithmetic it was stricter than our lenient re-score, which shows part of that gain is skill. Full write-up: training/RESULTS.md.

Can the reward be gamed?

Added after the training run above. Each family's own grader scores three answers that need no skill: the most common correct answer on the 400 training tasks (what GRPO would find), the question echoed back, and the task's input played back where it has one. A family can be gamed when the best of them pays more than the small model earns now and at least a tenth of the top reward.

Family	Best no-skill answer	Its score (200 held-out tasks)	Small model now	Can be gamed
propositional_logic	the premises joined with 'and'	0.993	0.010	yes
game_of_life	always an empty board (every cell dead)	0.962	0.000	yes
letter_counting	always "1"	0.350	0.045	yes
maze	always "5"	0.315	0.001	yes
word_sorting	the input words, unsorted	0.256	0.200	yes
sudoku	always one fixed answer	0.123	0.172	no
countdown	always one fixed answer	0.050	0.038	no
leg_counting	always "184"	0.025	0.000	no
basic_arithmetic	always "-2"	0.013	0.039	no
chain_sum	always "5"	0.010	0.029	no

A forward test: maze

The check flags maze. On the 400 training tasks the most common correct answers are "5" (114 tasks) and "6" (112), and answering "5" to every held-out task scores 0.315, while the small model earns 0.001. So before any maze training we published four claims (training/maze/predictions.json, 2026-10-31 22:31:12 UTC, SHA-256 4cca90e80a446fcb9286c2e9007450c7fd31e2d692f32b24d256eca118477cc8). The method is unchanged.

Claim	Test	Result
P1. Reward rises.	Mean held-out reward after training is above before, paired bootstrap p <= 0.05 (the same test as the six-family run).	held: mean reward 0.004 → 0.013, paired p < 0.001
P2. The model collapses onto one constant answer.	After training, a single answer string makes up at least 50% of the 200 greedy held-out answers.	held: 196 of 200 answers are the same text
P3. The constant is 5 or 6.	The most common answer after training is '5' or '6', the two most common correct answers on the training tasks.	failed: the constant is not a number: a grid of the numbers 1 to 20, cut off at 64 tokens
P4. No maze-solving skill is learned.	On held-out tasks whose correct answer differs from the model's most common answer after training, accuracy does not rise: paired bootstrap p > 0.05 for a gain.	held: exact answers 0 → 0 of 200

3 of 4 claims held. The model collapsed (98% of its answers are one text) and learned no maze-solving (0 exact answers before training, 0 after), but not onto "5". It found a different route, one the check didn't try: maze's grader (Reasoning Gym's default score_answer) pays len(answer) / len(reply) whenever the right answer appears anywhere in the reply, so the model writes a grid of the numbers 1 to 20. That grid contains the answer to all 200 held-out tasks and earns about 0.013 on each, so reward rose from 0.004 to 0.013 with no skill at all. The warning held; the guess at which cheat was wrong, and the miss is a second loophole in the same grader. Files: training/maze/results/.

A ladder inside one model

Higher efforts played one attempt per task and low effort three, so these are small samples.

Task suite	Share solved on the first try, by effort
Maze (maze_env)	low 100% · high 100%
Tic-tac-toe	low 89% · high 100%
Basic arithmetic	low 88% · high 88%
Chain sum	low 100% · high 100%
Countdown	low 67% · medium 75% · high 100%
Game of life	low 38% · medium 88% · high 88% · max 88%
Leg counting	low 75% · medium 75% · high 100%
Letter counting	low 67% · high 75%
Maze	low 75% · medium 88% · high 100%
Propositional logic	low 58% · medium 50% · high 75%
Sudoku	low 17% · medium 75% · high 100%
Word sorting	low 92% · high 75%

What's on the Hub

269 Spaces tagged openenv: the most-liked, plus a random sample of the rest. No model was used: each Space was woken, its OpenEnv routes tried, and one do-nothing and two random episodes played. Spaces still asleep got a second try with ten minutes to wake.

What happened	Spaces	Share
Running, but no standard OpenEnv API	79	29.4%
Runs and passes the floor checks	63	23.4%
Asleep, no answer within 10 minutes	36	13.4%
Scores above zero for doing nothing	30	11.2%
Broken (build or runtime error on the Hub)	25	9.3%
Crashes on reset or step	17	6.3%
Refuses a session	10	3.7%
Paused by its owner	9	3.3%

Files

Path	What it holds
episodes.jsonl	Every episode of the main run, one per line: suite, environment, player (policy), task, attempt, each step's action and reward, the return, tokens, and Beam's reasoning (trimmed to 2,000 characters per step). Episodes that failed for harness reasons are left out.
pilot_episodes.jsonl	The earlier pilot runs, before the harness fixes. Not used for any verdict.
verdicts.json	Per task suite: each rung's statistics, every check with its numbers, the verdict and who it was judged for.
census/	The Hub census (census.jsonl first pass, census2.jsonl second pass), the sample (chosen.json) and Beam's setups (setups/).
fixes/	For Connect 4: the evidence Beam was given, its reasoning, its reply and the patch.
training/	Pre-registration, predictions and their SHA-256, results, Beam's audit, the lenient re-score, analysis.json and RESULTS.md. training/maze/ holds the maze forward test.
gaming.json	The can-it-be-gamed check: every no-skill answer tried, per family, with its score.
code/	The Shortlist package, scripts, training code and the Kaggle notebook.

Reproduce

Python 3.12, OpenEnv at commit 739b44b525d174700c11c328618a5ba41d5f428f cloned into vendor/OpenEnv, and pip install -r code/requirements.txt (each environment's own requirements are also needed to serve it). A Beam key goes in REFLECTION_API_KEY (we keep it encrypted with dotenvx).

cd code
python scripts/ladder.py --suites maze_env --tiers null,random                  # floors only, no key needed
dotenvx run -- python scripts/ladder.py --suites rg:leg_counting --tiers null,random,beam-low
python scripts/report.py runs/<run>                                             # verdicts for a run
python scripts/hub_sweep.py --top 150 --random 150 --out runs/hub/sweep         # Hub census, no model
dotenvx run -- python scripts/setup_env.py --from-census runs/hub/sweep/census.jsonl --limit 20
dotenvx run -- python scripts/fix.py connect4_env --evidence runs/fixes/connect4_env.evidence.md
python scripts/figures.py && python scripts/export.py && python scripts/card.py  # numbers, page data, this card

Training: run training/shortlist_training_proof.ipynb on Kaggle (one T4). Part 1 writes the predictions and prints their SHA-256; commit that before Part 2, which refuses to train unless the SHA matches. Then training/rescore_lenient.py, training/audit_with_beam.py and training/analysis.py.

Limits

• Most environments judged for Beam have two to four tasks, so those verdicts are provisional.
• One small model, Qwen3-0.6B, and only on Reasoning Gym.
• Training ran 100 GRPO steps per family, once each. Only five answers per family were saved after training, so the trained models can't be re-scored leniently, and the trained adapters weren't kept.
• The lenient re-score regenerated the untrained model's answers with llama.cpp (Q8_0), not the fp32 weights used in training. The strict scores match closely.
• Beam's setups for community environments guess the score range. Where a player scored above the guessed maximum, the guess is ignored.
• Two Beam-side rules were added after the first results were in: a guessed maximum that a player beats is ignored, and environments judged for Beam need the same GRPO signal as the small model. Neither touches the pre-registered small-model rule.
• The can-be-gamed check covers Reasoning Gym only, tries three cheap strategies, and was added after the training run. A family it passes may still be gameable another way: the maze run found one it didn't try, a reply that contains every likely answer.
• The Hub census is a snapshot. Spaces sleep, wake and change.

License

Data: CC BY 4.0. Code (code/): Apache-2.0. Content that comes from each environment (its task text and observations, inside the episodes and the census) belongs to that environment's authors and keeps its own license.