5.5K+ RL tasks for hill-climbing small models in code and data science.

Data-analysis tasks as a plain, load-and-go dataset: no runtime, no framework required. Each row is one self-contained task: a real tabular dataset, a question about it, and a gold answer a bundled grader can check deterministically. Load it, prompt any model however you like, grade the result.

This is the front door. If you want the tasks as runnable sandboxed environments, use the Harbor suites; if you want demonstrations to fine-tune on, use -sft.

Splits

The held-out splits are harder than train by construction: train is 29% easy and 14% hard, the held-out splits are 11–13% easy and 38–40% hard. Worth knowing before you read any eval number.

What's in a row

Load it

from datasets import load_dataset

ds = load_dataset("FineEnvs/SmolDataEnvs", split="test")
row = ds[0]
print(row["question"], "→", row["answer"], f"({row['reward_mode']})")

Grab the data files for a task

The tables live in a Hugging Face bucket, so they come down with the bucket API rather than snapshot_download:

from huggingface_hub import list_bucket_tree, download_bucket_files

prefix = row["bucket_prefix"].rstrip("/") + "/"
items = [i for i in list_bucket_tree(row["hf_bucket"], prefix=prefix, recursive=True)
         if getattr(i, "type", None) == "file"]
download_bucket_files(row["hf_bucket"],
                      files=[(i.path, "input/" + i.path.split("/")[-1]) for i in items])

Grade a prediction

grader.py ships in this repo. It scores an answer through a ladder of checks: exact → numeric with atol/rtol → list and percent normalisation → symbolic equivalence:

from huggingface_hub import hf_hub_download
import importlib.util, sys

path = hf_hub_download("FineEnvs/SmolDataEnvs", "grader.py", repo_type="dataset")
spec = importlib.util.spec_from_file_location("grader", path)
grader = importlib.util.module_from_spec(spec)
sys.modules["grader"] = grader          # the dataclasses inside it need this
spec.loader.exec_module(grader)

r = grader.grade(row["answer"], my_prediction, reward_mode=row["reward_mode"],
                 abs_tol=row["atol"], rel_tol=row["rtol"])
print(r.reward, r.method)   # 1.0 exact | 0.0 miss

Where it comes from

Built from the jupyter-agent dataset, real data-science notebooks over 471 Kaggle datasets. Every question–answer pair was extracted and then verified: strong agent models had to solve the task in a live sandbox and reproduce the gold answer under deterministic grading. Anything ambiguous or un-checkable was dropped. So every task here is known-solvable and unambiguously gradable.

Verified by a checker, not judged by a model. Grading is an exact comparison against a known answer, through a ladder of checks: exact match → numeric with tolerances → list and percent normalisation → symbolic equivalence. No LLM sits in the reward path, so the signal does not drift when you change the grader's model, because there isn't one.

The family

Train on it

The simplest path, a notebook and a single-file script you can hand to HF Jobs, lives in FineEnvs/04-smoldataenvs.

Citation

@misc{fineenvs,
  author = {Kolavi, Adithya S},
  title  = {FineEnvs: Open Source RL Environments for LLM Agents},
  year   = {2026},
  url    = {https://github.com/adithya-s-k/FineEnvs}
}