Skip to content
Research

What we learn by running everything.

Notes from wiring every RL format into one contract and measuring what each environment actually does, written down with the evidence.

6Formatsdriven against their real packages
36Findingseach with its evidence and what we changed
167Episodes per secondprocess backend, 32 in parallel
1,775Prime Hub environmentspublicly searchable when we checked
Featured · September 2026

What we learned building Nenyax v0.1

Every format fits one of three modes. Across six formats there were no exceptions: an environment is stepped from outside, runs its own evaluation loop, or is a task graded by tests. So mode became a required field, and one call, rollout(), drives all of them.

Plug-and-play is a spectrum, so we measure it. The same driver reaches different tiers on different environments: public OpenEnv Spaces are evaluable, seeded servers trainable, and reasoning-gym audited. Reproducibility is rarely declared, so an environment is only resettable when seeding is asserted.

Honest numbers need honest failure. train() once reported a clean 0.000 while every episode was erroring on a wrong port; it now raises with the first error. And low scores from a small model were genuine: it answered without the required tags, which is exactly what training on these environments teaches.

At a glance

Gymnasium 1.3, reasoning-gym 0.1.25, OpenEnv 0.6, NeMo Gym 0.6, Verifiers 0.3.1 and Harbor 0.23, plus one real model, Qwen2.5-1.5B served by mlx-lm.

Read the full notes

What we measureddocs/learnings.md

Formats driven against real packages6
Held-out score, in-context learner, 2 rounds0.50 → 1.00
Episodes per second, process backend167
Sandboxed code tasks graded by hidden tests8/8
Formats

Results by format.

Which tier each format reached when driven end to end, and why.

ModeTier reached
reasoning-gymthe gold answer gives a free oraclestepaudited
NeMo Gyma clean /verify contract over HTTPstepaudited
Verifiersgsm8k scored gold 1, wrong 0rolloutaudited
Harbororacle and nop give a built-in audittaskaudited
Gymnasiumno oracle exists, so no auditsteptrainable
OpenEnvseeded servers; public Spaces are evaluablesteptrainable
Topics

Four threads we keep pulling.

Tiers are measured by running the environment: connectable, evaluable, trainable, audited. A check that can't run blocks its tier, and the audit is task-aware because oracles only know one task's answer.

nenyax checkreasoning_gym:basic_arithmetic

Connectableloads, an episode can start
Evaluablea full episode completes
Trainableseeded and recorded
Auditedthe verifier discriminates
Speed

Where the time goes.

Per-episode cost varies by four orders of magnitude across formats. Scripted reasoning-gym episodes take under a millisecond; a Harbor agent in a container takes 16 to 25 seconds, dominated by container and agent setup.

That is why pooling Verifiers serving and Harbor containers across episodes is near the top of what we improve next, along with Docker throughput, which sat at 1.3 episodes per second under load on Docker Desktop.

Timingsper episode

reasoning-gym< 1 ms
NeMo Gym over HTTP~20 ms
OpenEnv Space, per step~0.3 s
Verifiers v1, local model~1–4 s
Harbor, terminus-2~16–25 s
Questions

Good to know.

From our own runs against the real packages, recorded in the SDK's learnings notes with the evidence for each finding.

Run the experiments yourself.

Everything here comes from runs you can repeat with the SDK.