whileai.simulations.environment

​

build_tasks

build_tasks(
    rows: Sequence[dict],
    holdout: float | Sequence[str] = 0.2,
    band: tuple[float, float] | None = (0.2, 0.8),
    ngram: int = 8,
) -> tuple[list[dict], list[dict], dict[str, Any]]

​

export_environment

export_environment(
    source: Any,
    out: str | Path,
    name: str | None = None,
    reward: Any = None,
    execute: Any = None,
    system_prompt: str | None = None,
    tools: Sequence[dict] | None = None,
    holdout: float | Sequence[str] = 0.2,
    band: tuple[float, float] | None = (0.2, 0.8),
    max_turns: int | None = None,
    description: str = '',
    ngram: int = 8,
    world: Mapping[str, Any] | None = None,
    harnesses: Sequence[Any] | None = None,
    runtime: str = 'verifiers',
) -> dict[str, Any]

• source: a SimulationData (system prompt and tools come from its profile), a row list, or a JSONL path; graded rows get the difficulty band, ungraded rows are exported as they are. For a list or path pass system_prompt and tools.
• reward: a Verifier, a judge callable honoring the SDK judge contract, or 'module:attr'; it must be importable in the trainer process. A @verifier or All([...]) bound to a name in your own module is referenced by that name (a script run as __main__ by its file stem, so keep that directory on the trainer’s path). With no reward the conduct grade is used and the report warns: it is a process reward, and a policy trained on it alone learns to call nothing (see recipes/03-select/prime-intellect-rl).
• execute: a live world (tool, arguments) -> result; without it the SDK’s mock world answers, seeded per task so every rollout of a task sees the same world.
• world: the mock world’s dials as a dict (WorldOptions fields: search_hits, exists_share, default_fault_mode, name pools, …). It is written into spec.json and the trainer’s world is built from it, so the world a policy trains against is the one the export says.
• holdout (0.2): the share of tasks held out, split by scenario id (or the prompt) so a task is wholly on one side, or an explicit list of holdout prompts.
• band ((0.2, 0.8)): the pass-rate band a graded prompt must sit in; prompts the policy always or never solved carry no advantage and are dropped (Lambert 2025, chapter Reasoning, difficulty filtering at 20 to 80 percent; DAPO’s dynamic sampling, arXiv:2503.14476). None keeps them all.
• ngram (8): the train-versus-holdout decontamination size, the overlap Lambert 2025, chapter Evaluation, found its contaminations with.
• name, description, max_turns: the package name, its README line, and the rollout turn cap (the SDK default when None).
• harnesses: wai.Harness objects (or plain \{label, instructions, tools\} dicts) the trainer’s rollouts run under. Each task draws one from its id and a seed, and that harness’s instructions become the system prompt and its tool schemas the tool set for the rollout; a harness with no tools of its own uses the environment’s. The spec lists them as \{label, hash, instructions, tools, disclosure\} and every rollout records harness = \{label, hash\}. Kim et al. 2026 (arXiv:2606.25447): a policy trained under one fixed harness collapses when the tool environment shifts, and harness-aware post-training generalizes out of distribution. Left out, the spec is what it always was.
• runtime ("verifiers"): the trainer contract the package speaks. "verifiers" is the Prime Intellect package prime-rl and TRL’s verifiers path install with pip install -e; "openenv" is Meta PyTorch’s OpenEnv (reset/step/state over HTTP, the contract TRL, torchforge, SkyRL and Unsloth drive), written as an openenv.yaml package that uv run --project . server serves, openenv build containerizes and openenv push puts on a Hugging Face Space. Same tasks, world and reward either way; see whileai.simulations.openenv.

report = wai.export_environment(data, "envs/refunds", reward=my_verifier)
print(report["train"], report["holdout"], report["path"])

​

load_environment

load_environment(
    spec: str | Path | dict,
    split: str = 'train',
    reward: Any = None,
    execute: Any = None,
    world: Any = None,
    harness_mix: str | Sequence[float] = 'uniform',
    harness_seed: int = 0,
    **kwargs: Any,
) -> Any