Datasets:

EnvLoop
/

Recursive-Play-Bench

pretty_name: Recursive-Play Bench
language:
  - en
task_categories:
  - reinforcement-learning
tags:
  - rl-environment
  - tabular
  - interactive-environments
  - puzzles
  - agent-evaluation
  - environment-generation
  - rsi-research
size_categories:
  - 1K<n<10K
configs:
  - config_name: models
    default: true
    data_files:
      - split: test
        path: model-summary.jsonl
  - config_name: tasks
    data_files:
      - split: test
        path: tasks.jsonl
  - config_name: results
    data_files:
      - split: test
        path: episodes.jsonl
  - config_name: challenges
    data_files:
      - split: test
        path: challenge-tasks.jsonl
  - config_name: families
    data_files:
      - split: test
        path: family-summary.jsonl
  - config_name: depths
    data_files:
      - split: test
        path: completion-depths.jsonl

Recursive-Play Bench

150 executable puzzle environments, six sequential levels per environment, and 1,650 independently eligible model/environment results across eleven configurations. AI-assisted construction supplies witness-solvable challenges that tested agents do not yet finish. Fifteen tasks have no complete six-level win from any evaluated configuration; two have zero completed levels across all eleven configurations.

Author and contact: EnvLoop Research — research@envloop.ai.

The Recursive Play collection brings together the dataset, practice Space and links to the paper and its sources.

The paper explains the task construction, fixed-budget evaluation, matched-case examples, uncertainty and prospective improvement pathway. The editable source places main.tex at the archive root and preserves its relative staging/ and figures/ paths. It contains no authoring runtime, operational evidence or private checks. This release contains task metadata, executable environment source and selected outcome tables. It contains no model weights, complete training trajectories or measured training/RSI gain.

Explore the dataset on Hugging Face

The native viewer provides six configurations. Each uses JSONL, so the configurations share a compatible loader while retaining their separate schemas.

Configuration	Rows	What you can inspect
models	11	Ranked configuration results and selected-case resource coverage
tasks	150	Actual task identities, canonical seeds, mechanics and quality flags
results	1,650	Every selected episode, with the original cell strings preserved
challenges	15	Tasks no evaluated configuration completed under the recorded budgets
families	110	Eleven configurations across ten authored families
depths	77	Counts at all seven completion depths for every configuration

models is the default view. The three aggregate tables are calculated from the frozen final summary and outcome matrix. They are additional views of the same 1,650 episodes, not new trials. Every model offers 150 episodes and 900 levels; every model/family pair offers 15 episodes and 90 levels. Depth counts sum to 150 per model. primaryRank preserves ties, while displayOrder records the paper's stable ordering of tied configurations.

Numeric columns support the native viewer's distribution charts and value filters. Missing token totals and unpriced costs remain JSON null. Known token and monetary figures remain subtotals; unknown-use reservations are not invoices. Request-grain and episode-grain missingness remain separate in tokenUsageGrain and must not be added into a single missingness rate. Family percentages and depth shares are calculated directly from their stated denominators without changing any counts.

Load a configuration reproducibly

The aggregate views are available at the recorded commit e519f64ccc67fb4fc32a393b9f3a77597432336c. Passing this hash loads the published summary tables reproducibly. Later card-only revisions do not change the data at this commit. You can inspect other revisions under Files and versions.

from datasets import load_dataset

repo = "EnvLoop/Recursive-Play-Bench"
revision = "e519f64ccc67fb4fc32a393b9f3a77597432336c"
models = load_dataset(repo, name="models", split="test", revision=revision)
families = load_dataset(repo, name="families", split="test", revision=revision)
depths = load_dataset(repo, name="depths", split="test", revision=revision)

The original task and result configurations, together with the V14 paper, are also available at the existing audited revision cb12d923f369109626b083ae6e44a3139abedca9. That revision predates the aggregate views.

raw_revision = "cb12d923f369109626b083ae6e44a3139abedca9"
tasks = load_dataset(repo, name="tasks", split="test", revision=raw_revision)
results = load_dataset(repo, name="results", split="test", revision=raw_revision)

The V14 paper and LaTeX source archive use the same recorded revision. No DOI or arXiv identifier is claimed.

The test label organises these exposed research records. It does not turn them into an independently hidden acceptance set. See the official loading guide for configuration and revision parameters.

Query an aggregate in Data Studio

Open models/test, then open its SQL Console. Hugging Face registers this selected view as models, which is the table name used below. The query follows the paper's recorded display order and retains tied ranks.

SELECT primaryRank, displayName, fullWins, fullWinRatePercent,
       levelsCompleted, levelClearRatePercent
FROM models
ORDER BY displayOrder;

Open the saved Ranking and Model Performance query to inspect the same eleven rows directly in the native SQL Console.

The SQL Console also lists the challenge view as challenges. This query reproduces the paper's challenge ordering using the task-level completion and reference-action fields:

SELECT environmentId, family, maximumCompletedLevelsAcrossEleven,
       astraCompletedLevels, referenceTotalActions
FROM challenges
ORDER BY maximumCompletedLevelsAcrossEleven,
         referenceTotalActions, environmentId;

The saved Challenge Levels and Actions query opens these fifteen challenge rows in the same order.

The native SQL Console can share query results and export tables. The Data Studio guide explains filtering, search, missing-value distributions and row sharing. These facilities inspect the recorded outcomes; they do not run a solver or create a new benchmark score.

Files and configurations

File	Contents
`tasks.jsonl`	150 actual environment records with immutable IDs and canonical seeds, authored mechanics, source hashes, quality flags and reference action counts
`episodes.csv`	Exact final 1,650-row outcome table; eleven configurations, 150 environments each
`episodes.jsonl`	Viewer-compatible JSONL projection of the same 1,650 CSV rows; all 14 cells per row remain strings, including empty cells
`summary.json`	Unmodified final score and resource summary, including known/unknown use and eligibility accounting
`model-summary.jsonl`	Eleven typed model aggregates with tied ranks and unchanged resource coverage
`family-summary.jsonl`	110 typed model/family aggregates with explicit 15-episode and 90-level denominators
`completion-depths.jsonl`	77 typed model/depth counts with a 150-episode denominator
`original-930.csv`	Exact preserved earlier 930-row table; every field is retained in the final table
`challenge-tasks.jsonl`	Fifteen tasks left unfinished by every configuration, with exact completion-depth vectors
`challenge-inventory.json`	Existing curated evidence for those fifteen tasks and the canonical reference validation
`environment-source.zip`	Ten source modules plus their standard-library-only interface, registry and generation plan
`recursive-play-paper.pdf`	The revised 24-page English paper with complete explanatory prose
`paper-source.zip`	Exactly 38 LaTeX compilation inputs: `main.tex`, included sections, bibliography, five vector figures and twenty recorded PNGs
`SHA256SUMS.txt`	File hashes for this release payload

The six Hub configurations all read JSONL. tasks reads tasks.jsonl, while results reads episodes.jsonl as a lossless view of the original outcome CSV. episodes.csv remains the unmodified authoritative CSV. The JSONL is a lossless cell-for-cell projection: no fields, identifiers, scores or empty values are changed or coerced. All configurations use a test split label for organisation. This bank was exposed during development: that label does not make it a sealed or independent held-out test set. No train/validation partition or new training labels are fabricated.

What a task record means

environmentId and canonicalSeed reproduce the evaluated instance. Every environment has six levels. family is the paper's author category; sourceFamily preserves the implementation category. Mechanics and mechanism notes describe the authored rules, not independently certified novelty. sourceArchiveMember locates the exact module in the source ZIP; its SHA-256 is recorded beside it.

The author API implements init(level, seed), observe(state), step(state, action) and solved(state). The source archive preserves its original module layout so imports resolve after extraction. It uses the project's Node runtime requirement (Node 26.7 or newer) and standard-library facilities. Source contains author state and constructive witnesses. A blind solver must receive only projected observations and neutral controls, never author metadata, seeds, source, state or witnesses.

All 900 canonical seed/level references were replayed successfully: 20,092 reference actions, with a maximum 347-action six-level curriculum. Separately, the construction audit exercised 2,700 level instances at three default seeds. These counts are different audits. A constructive path establishes reachability and action-budget feasibility; it is neither an optimal solution nor proof that a blind agent can discover it within the time limit.

The construction manifest declares zero independently certified-hard environments and retains quality flags for 42 environments. All flags remain in the task records; human difficulty calibration and independent novelty validation remain absent. Easy candidates stay in the full 150-task denominator.

Scores and protocol

Each fresh episode uses the original model identifier, canonical seed and blind prompt, with 512 charged actions and 720 seconds across all six levels. Reset costs an action; advancing after a confirmed level win is free. The first independently eligible outcome is selected regardless of score. Confirmed engineering interruptions are handled separately under evidence review; raw attempts remain preserved in the private audit store.

Complete-task rate: six-level wins divided by 150 tasks per configuration.
Cleared-level rate: attained levels divided by 900 offered levels per configuration.
The complete table has 1,650 outcomes = 11 configurations × 150 tasks.
It reuses the earlier 930 results unchanged and adds 720 independently audited results.
Equal complete-task counts retain tied ranks; cleared-level totals order tied rows for display.

An ordinary time_budget ending means the six-level curriculum was unfinished when the game clock expired. Partial progress remains credited. Among 1,255 ordinary time-budget endings, 484 completed at least one level. Waiting for model responses, tools and gameplay all consume the clock; that endpoint alone does not identify a cognitive or engineering cause. Ordinary time/action exhaustion remains in the score denominator. Zero completed levels does not prove that no meaningful observation occurred.

The strongest observed configuration completes 135/150 tasks. The remaining fifteen tasks have no full win from any of the eleven configurations. This is a result under the recorded budgets and serving/tool setups, not a universal impossibility claim or a model-only causal comparison. Known usage subtotals and retained unknown quantities are not silently converted into complete totals or zero cost.

Intended use and limits

Use this exposed bank for environment research, reproducible result analysis, development diagnostics and prospective corrective-data experiments. The task source and privileged references are public author resources, so new confirmation experiments must freeze a distinct acceptance set and isolate solver access. Source hashes and replay check recorded consistency; they do not certify semantic fairness, human learnability or operating-system attestation.

The proposed improvement pathway is to select verified failures, obtain corrected trajectories, train a candidate and test it on independently frozen tasks with retained baselines, no-regression checks and rollback. This release does not demonstrate trained improvement, persistent adaptation or recursive self-improvement. It does not implement an autonomous general RSI system.

Rights and permissions

No project-wide redistribution license is declared in the source snapshot; contact research@envloop.ai for permissions. No new permissive or research-only license is invented here. No third-party runtime dependencies are bundled: the environment archive contains the project's authored modules and standard-library interface only. Bibliographic sources and figure references remain in the paper.

Citation

@misc{envloop_recursive_play,
  title = {Recursive-Play Bench},
  author = {{EnvLoop Research}},
  url = {https://huggingface.co/datasets/EnvLoop/Recursive-Play-Bench}
}