Skip to content
Bud's Wiki

RL Environment Platforms

TL;DR

Section titled “TL;DR”

Across the recent filings, “RL environment” has become a packaged, distributable artifact — a Docker-bootstrapped backend + per-task verifier + standardized agent-interaction interface — rather than a per-project research scaffold. The three filed instances span a clear scale gradient: SETA ships ~400 Terminal-Bench-compatible tasks as a single-repo synthesizer, Toolathlon-GYM ships 503 MCP/PostgreSQL enterprise-workflow tasks as a Docker Compose stack, and OpenReward ships 330+ environments × 4.5M+ tasks behind a managed API governed by the Open Reward Standard (ORS, an MCP extension). The unifying bet: standardize the env↔trainer interface, decouple env compute from training compute, and the “scrape-domain-Q&A → auto-generate verifiable tasks → GRPO” pipeline becomes plug-and-play across domains.

Key claims

Section titled “Key claims”

Recent contributions

Section titled “Recent contributions”
  • [2026-11-04] Inspect Robots: Evaluating the Capabilities and Safety of Embodied AI: Paper companion to the stable release of Inspect Robots (Inspect Robots — An Open-Source Evaluation Framework for Physical AI (Robocurve)), formalizing the Task = scenes + controller + scorer + two-slot (Policy, Embodiment) design with pre-actuation compatibility check and immutable EvalLog as a publishable real-hardware eval substrate — presented at the Science of Physical AI Safety workshop at CoRL 2026. Reports nearly 100K downloads in the three months since release, the sharpest filed adoption datapoint for any real-hardware eval substrate in this cluster. Demonstrates the framework by evaluating six frontier-LLM-based policies; per-policy numbers not retrievable from the abstract.
  • [2026-11-04] RoboColosseum launch — open real-world robot eval initiative with 100+ robots, 140+ scenes, 10,000 free eval hours: RoboColosseum (Hugging Face / LeRobot + BitRobot Network + EAIC Singapore + Jiafei Duan’s MAGIC Lab) launches an open real-world robot-eval initiative that stakes out a fourth protocol-position in this cluster’s real-hardware sub-row — a centralized multi-embodiment fleet (100+ robots: Unitree G1s, i2rt bimanual YAMs, LeRobot SO-101, Franka arms, Earth Rovers) across 140+ in-the-wild scenes (homes, restaurants, outdoors), with two eval tracks (open-world zero-shot blind + fine-tune within-distribution on fixed open-source datasets) and 20,000+ runs already logged. Differentiates from RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies (distributed crowd-sourced pairwise A/B), Reality Check — Pokeandwiggle's Real-World Robot Manipulation Leaderboard on an FR3 Duo Farm (centralized single-embodiment FR3-Duo farm), and Inspect Robots — An Open-Source Evaluation Framework for Physical AI (Robocurve) (ship-your-own-hardware harness) on embodiment coverage — the first centralized farm this page tracks to span humanoid + bimanual + single-arm + outdoor rovers simultaneously. All rollout data (including failures) open-sourced on Hugging Face / LeRobot, with 10,000 free eval hours offered to academic labs. Launch tweet only; no per-task throughput, verifier design, or quantitative benchmark numbers surfaced — the “policy rankings varied by task and robot” observation across 20k+ runs is the only qualitative result published.
  • [2026-11-03] Democratizing Robot-Use Agents: A Unified Harness with Open Models: uni-robot-agent (Yuan, Zuo, Huang et al.; Berkeley + Tsinghua) uses RoboDojo (RoboDojo: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies) as the shared sim-and-real substrate for the first filed head-to-head between an open-weight-LLM-as-controller harness and the published GPT-6 Astra-RoboProbe entry — Qwen3.8-Flash-Next reaches 31.39 vs Astra 28.97. Makes RoboDojo the common axis for comparing LLM-as-controller (this paper, Astra-RoboProbe), code-at-test-time (Embodied Turing Machines: Stateful Code for Robot Recursive Self-Improvement COAP 70.24%), and WAMs (InternW0-Δ: A World Action Model Bridging Predictive Dynamics and Actions with 20K+ Hours of Open Data InternW0-Δ 23.9%) under one scoring convention.
  • [2026-11-03] Do robot policies transfer between physics engines?: Manda Robotics runs the first filed systematic cross-engine policy-transfer study across the four simulator substrates this concept catalogs — same assets, same PPO recipe, trained in MuJoCo / PhysX / Newton (MuJoCo-Warp) / Genesis and swapped at eval. The negative-transfer numbers are sharp: 49/50 MuJoCo insertions collapse to 11/50 in PhysX GPU on the worst seed, Isaac Lab’s own validated grasp-and-lift transfer still loses 20–29 points (88%→68%, 82%→53%), and generalist π0.5 shows 41 vs 13 failed grasps across matched Newton/PhysX episodes with scenes-at-rest in one engine not at rest in the other. A single PhysX solver swap (TGS 100/1 → PGS) moves a fragile policy from 5/25 to 21/25 at p=0.001 without changing weights, directly bounding how trustworthy “swap simulators freely” is for any entry on this page. Also surfaces silent URDF-level divergences: identical foot friction authored as 0.8/0.6 is resolved to 0.6–0.8 (product) in PhysX but 1.0 (max) in Newton. Argues for the vendor-aligned single-engine stacks on this page (Microduck RL — RL training environments for a ~800 g open-source bipedal robot, Dex-SuperMimic — Reproducing SuperMimic on Dexterous Hand Manipulation, Project SuperDex — A unified simulation platform for dexterous manipulation) as the structurally safer bet when sim-to-real is the eventual target.
  • [2026-11-02] WUJI Hand 2 autonomous pen spinning with disturbance rejection via RL + motion-reference tracking: WUJI Tech’s vendor-internal pen-spin demo on WUJI Hand 2 (sim RL + motion-reference + sim-to-real) is the hardware-vendor counterpart to the Dex-SuperMimic — Reproducing SuperMimic on Dexterous Hand Manipulation Dex-SuperMimic open stack (mjlab + MuJoCo Warp + Wuji MJLab tasks) targeting the same hand + pen-spin task — datapoint that the vendor-aligned-sim + motion-reference-RL pattern is converging between vendor and community implementations on identical hardware.
  • [2026-10-30] DexHoldem: An Agentic Robotics Benchmark for Dexterous Manipulation in Texas Hold'em: DexHoldem (Chen et al.; HKU + Berkeley) packages a real-hardware dexterous-manipulation benchmark around Texas Hold’em with a discrete enumerable ground truth (8-field game state parseable per frame) — a rare property on this concept’s real-hardware side where ground truth is usually implicit task-success. Ships three coupled surfaces: 1,470 teleop demos across 14 card/chip primitives for policy training, 36 snapshot problems for frontier-VLM-as-perceiver evaluation (Codex / Claude Code / Gemini CLI × GPT 5.4/5.5 / Opus 4.7 / Gemini 3 Flash), and three full-system case studies. Sibling to Inspect Robots — An Open-Source Evaluation Framework for Physical AI (Robocurve) Inspect Robots and Reality Check — Pokeandwiggle's Real-World Robot Manipulation Leaderboard on an FR3 Duo Farm Reality Check on real-hardware eval, but differentiating by (a) coding-agent harness as the first-class interface to the perceiver and (b) field-wise diagnostic attribution — a VLM gets credit for turn-ownership (TO 68.5–94.4%) separately from community-card parsing (CC 23.1–61.5%) separately from showdown outcome (SO 0.0–76.2%), which the whole-task Robocurve/Reality Check protocols cannot do.
  • [2026-10-29] Dex-SuperMimic — Reproducing SuperMimic on Dexterous Hand Manipulation: Dex-SuperMimic packages SuperMimic-style training on dexterous Wuji Hands as a uv-managed mjlab + MuJoCo Warp stack with three task configurations (hand1-reorient, hand2-reorient, hand2-pen-spin), CLI training/playback, and pretrained 8K-iteration checkpoints — joins Microduck RL (Microduck RL — RL training environments for a ~800 g open-source bipedal robot), OCBench (OCBench — A Controllable Robotic Manipulation Benchmark for BC and RL), and Cyclo (Cyclo — ROBOTIS Open-Source Modular Physical AI Framework) in the hardware-vendor-aligned MuJoCo training-stack cluster, with the differentiating property that the training objective is model-based (BPTT through a learned WFM) rather than the PPO-dominant pattern elsewhere.
  • [2026-10-28] Reconstruct, Practice, Go Real: Guided Self-Improvement for Embodied Agents: RPG (Berkeley) uses the simulator as the practice substrate for a no-weight-update self-improvement loop: capabilities are mined from an offline dataset and related practice tasks are reconstructed in simulation as the curriculum, with privileged simulator state exposed to the diagnostic multimodal LLM alongside execution feedback and dataset videos. Candidate skill edits are validated across the practice-task suite before retention. Reports 28.6% → 95.0% on 22 held-out initializations over 15 rounds, outperforming ASPIRE (75.5%) and CaP-Agent0 (GPT-6 Astra Pro, 60.0%), and 30/30 real-robot trials across three tasks. Reinforces the pattern (ASPIRE, RoboRSI, SwarmRSI, GRID Auto-Engineering, ENPIRE) of sim as the per-task self-evolution substrate for a shipped artifact that is prompt + code rather than policy weights.
  • [2026-10-28] RE-0: Verified Recursive Improvement of Embodied Code-as-Policy Agents through Local On-Policy Distillation: RE-0 uses robosuite as the environment substrate but makes a new design move on this concept’s “verifier-cheap, action-expensive” axis: the per-event LCB admission gate functions simultaneously as the verifier for training-data admission and as a measurement instrument for teacher effect — before any training, the same gate applied to different candidate teachers produces a monotone ladder (student self-play 0/34 admitted, narrow local experts 0/32 admitted with a 10% rescue ceiling + deterministic contract-format failures, strong API teacher 4 admitted on 13 events with 19–47% rescue rates). Direct quantitative statement that who holds verifiable local credit on the student’s failure history is a measurable property of the teacher–environment pair, distinct from “who scores higher globally”. Also reports that the LCB gate’s strict statistical admission costs no sensitivity (admitted events cluster at A^≥0.25\hat A \ge 0.25, abstained at A^≤0.08\hat A \le 0.08, sweeping the threshold 0.24 → 0.01 leaves the admitted set unchanged) and is two-sided (one patch that dropped baseline 8/16 → 1/16 was correctly rejected). Reinforces the “verifier compute + action compute asymmetry” framing already on this page by making the verifier do double duty as an auditable measurement surface for upstream teacher-selection decisions, with ~3–67 verified rows per task driving 4–68% → 62–100% end-task success — a sharp operating point on the “cheap verifier, expensive-but-targeted actions” axis.
  • [2026-10-27] Introducing Clef: our open-source decision models, and new RL fine-tuning platform: Cloudflare’s Clef RL fine-tuning service applies the verifier-cheap / action-expensive env-platform pattern one layer up: AI Gateway auto-captures request/response pairs as the training substrate, Workers AI generates rollouts against the base model, Containers host RL sandboxes for scoring/replay, a new Trainer updates weights, and BYO Model redeploys to Workers AI — first filed instance of the env-as-package design closed end-to-end for decision-model customization on a single cloud provider’s primitives.
  • [2026-10-23] NVIDIA Robotics announces Isaac Lab 3.0 — Newton multi-physics, OVRTX, RL Post Training, LEAPP deployment: Isaac Lab 3.0 (NVIDIA Robotics) ships a modular rewrite of the first-party GPU-parallel sim substrate behind many entries on this page — Newton as a multi-physics core (MJWarp articulated rigid + MPM particles + VBD deformables with coupling), a new OVRTX path-traced renderer plus Cosmos 3-Nano Transfer for photorealism, perception-in-the-loop training that scales single-GPU → cluster, Isaac RL Post Training (RLPT) on GR00T, and LEAPP deployment bundles that package the policy’s compute graph + metadata for real-hardware transfer. Launch-tweet only; no throughput, benchmark, or sim-to-real numbers reported, so the position-relative-to FLASH: Fast Learning via GPU-Accelerated Simulation for High-Fidelity Deformable Manipulation in Minutes FLASH (256-env Newton 480.6 ms/step datapoint), HydroShear: Hydroelastic Shear Simulation for Tactile Sim-to-Real Reinforcement Learning HydroShear, Genesis World — Simulation platform for general-purpose robotics & embodied AI learning Genesis, and Project SuperDex — A unified simulation platform for dexterous manipulation Project SuperDex is unmeasured. Tracked here as infrastructure: the four-stage pipeline (multi-physics → multi-rendering → parallel RLPT → LEAPP deployment) is the vertically-integrated first-party reference for the sim-platform recipes multiple entries on this page have been assembling piecewise.
  • [2026-10-19] Blind Precise Assembly: Proprioceptive Sim-to-Real Peg-in-Hole for Diverse Parts: Bronars, Park, Kedia & Agrawal (MIT) open-source mjfit — a procedural MuJoCo asset generator that builds tight-clearance assembly scenes (peg insertion, gear meshing, nut threading) from exact convex pieces, keeping designed sub-mm clearances intact at collision time. Addresses a specific sim-infrastructure gap: V-HACD / CoACD convex decomposition fills tight clearances with convex-hull overshoot so parts jam, and MuJoCo’s SDF collision preserves geometry but is slow and hard to tune. Used by the paper’s pure-sim PPO + domain-randomization training recipe for blind-proprioception assembly policies that transfer zero-shot to the real world (73% across 8 pegs incl. 0.5 mm clearance). Complementary infrastructure to Microduck RL — RL training environments for a ~800 g open-source bipedal robot Microduck RL and other MuJoCo-based PPO stacks on this concept — targets the asset-import rather than the training-loop side of the sim stack.
  • [2026-10-19] Has GPT-6-Astra Achieved Embodied Intelligence?: SenseNova Joint Research Team prototypes a next-generation embodied benchmark whose contract inverts the usual one — tasks derived from real-world needs, no in-domain demonstrations, and a world clock that keeps running while the agent deliberates — operationalizing the deliberation-vs-execution trade exposed by frontier-model-as-policy measurements as a first-class scoring axis.
  • [2026-10-16] ASPIRE: Agentic /Skills Discovery for Robotics: ASPIRE uses CaP-X (CaP-X: A Framework for Benchmarking and Improving Coding Agents for Robot Manipulation) over MuJoCo Playground + Robosuite + BEHAVIOR-1K as its simulated-environment substrate and a bimanual YAM station as its real-robot substrate — co-training across a sim stack + a real embodiment with different perception, calibration, control, and API surfaces. Supports the “sim+real environment substrate for an evolutionary / debug-and-refine inner loop” row on this page alongside ASPIRE — self-evolving sensorimotor skill library that compounds across robots and the sim-to-real gap (Jim Fan / NVIDIA GEAR), and provides the first filed concrete measurement of how much sim→real debugging cost a validated skill library saves (Table 1: ~9.4× token reduction on soda-can lifting across Franka → YAM embodiment change).
  • [2026-10-15] HumanoidToolBench: Benchmarking Humanoid Tool Use from Selection to Mobile Execution: HumanoidToolBench ships as a reproducible evaluation artifact: uv run htb-eval CLI across 18 tasks on simulated + real Unitree G1, Linux + NVIDIA GPU, pluggable --policy my_policy:predict interface returning (T, 36) actions, released checkpoints for all seven evaluated policies via HuggingFace. Standardizes a five-event sub-success chain (candidate contact → correct first contact → correct-tool lift → tool-target contact → success) as the per-episode logging contract, usable as a shared diagnostic across backbones.
  • [2026-10-13] Gemini 4 Argon for Robotics: Argon-authored MuJoCo environments are a new instance of LLM-generated RL env substrates: the 12-ball balance-puzzle prompt specifies articulated Roberval scale physics via mjEQ_JOINT parallelogram constraints, visually-identical ball instances with one secret 270 g or 30 g odd ball, Red (Heavy) / Blue (Light) submission trays, a reward of 1.00 for isolating the odd ball in the correct tray within ≤3 weighings, and privileged-observation-free (add_privileged_task_observations=False) stereo RGB solvers. The humanoid-throw prompt specifies a 50 Hz four-phase trajectory + physics-verified knockdown gate. First-party reference pattern for “frontier LLM writes the RL env + the policy + the verifier in one session” at the humanoid / long-horizon manipulation scope.
  • [2026-10-12] RoboRSI: Stable, Efficient, and Reusable Robot Self-Evolution in Complex Real-World Environments: RoboRSI uses the LIBERO + LIBERO-PRO + LIBERO-Plus + RoboTwin sim stack as a shared evaluation substrate for a coding-harness self-improvement loop, reporting SOTA across all four with +2.7–11.0 pp over the strongest baseline. The paper’s 840-instance stratified perturbation panel (7 categories × 120: visual texture / camera viewpoint / language instructions / lighting / object layout / robot initial state / sensor noise) built on top of LIBERO base is a datapoint for how multi-benchmark sim platforms are used not just to rank frozen policies but to drive multi-round agentic revision — the Reviewer uses perturbation-category failures as attribution signals routed back along the skill-tree call path. Companion deployment is a real mobile manipulator (104-round household cleanup), making this one of the few filed systems that spans the same four-agent harness across sim platforms and real hardware with the sim platforms serving the role of a controlled attribution substrate rather than a terminal eval target.
  • [2026-10-10] A Balanced Data Diet: Addressing the Exploration Bottleneck in Mega-Scale RL for Robot Control: SGS scales to 2^20 (~1M) parallel simulated environments inside Isaac-Lab-style GPU sim and reports that at this env count, standard uniform sampling over the reset distribution becomes the primary bottleneck — the sampler saturates the batch with low-signal transitions well before PPO’s optimizer or the sim’s physics give out. Sharpens the “verifier-cheap, action-expensive” design frame on this page by showing that at the extreme end of the action-compute axis, batch composition becomes a first-class design axis distinct from env-synthesis quality or verifier design. Also a datapoint that general-purpose multi-physics platforms (Isaac Lab) can host contact-rich NIST assembly RL end-to-end to zero-shot real UR5e transfer when paired with the right sampler — relevant to the sim-first vs real-eval axis the page already tracks.
  • [2026-10-08] Reality Check — Pokeandwiggle's Real-World Robot Manipulation Leaderboard on an FR3 Duo Farm: Reality Check (Poke & Wiggle, Deutsches Museum Munich) stakes out a centralized real-hardware eval farm on bimanual Franka FR3 Duo stations as a third protocol-position alongside RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies RoboArena (distributed crowd-sourced pairwise A/B) and Inspect Robots — An Open-Source Evaluation Framework for Physical AI (Robocurve) Inspect Robots (ship-your-own-hardware harness) — 14,400 rollouts across four open VLAs (π0.5, MolmoAct 2, GR00T N1.7, DiT-Flow) × 10 environments × 3 nested data tiers (D10/D100/D300) × 2 spatial-generalization conditions (nominal/interpolation; extrapolation + M100 100-h mid-training tier declared future axes) × 30 rollouts per combination. The protocol-differentiating moves are physics-verified per-rollout object placement (>40,000 placements across the benchmark, each verified by a 3D scene-understanding + object-tracking pipeline before rollout), remote-only policy-server integration (no shipping lab touches the hardware), eight-metric reporting with 95% CIs (success rate, task progress, execution quality, time, speed, SPARC smoothness, jerk, safe-failure rate, max contact force from joint-torque sensors), and double-review + QA-sampled annotation with a publicly logged re-annotation changelog (9 rollouts corrected post-release across the four models, <1% execution-quality shift and <0.1% progress shift — first filed quantitative stability number for small-N real-hardware per-rollout human annotation). Dataset release is asymmetric by design: 5 environments (e01, e03, e04, e05, e09) open with all training data + eval rollouts + placements; 5 (e02, e06, e07, e08, e10) fully held out.
  • [2026-10-07] FLASH: Fast Learning via GPU-Accelerated Simulation for High-Fidelity Deformable Manipulation in Minutes: FLASH is a specialized GPU-native deformable-object simulation platform (not RL-training-oriented in the InfTool / SETA sense, but sits in the same slot as Isaac Lab / Newton / Genesis for robot learning). Reports head-to-head throughput at 256 parallel envs: FLASH 185.1 ms/step, Newton 480.6, Isaac Sim 47.8 (fastest but least physically faithful on cloth), Genesis diverges at ≥32 envs. The design move worth filing: an inertia-dominated contact-metric approximation (Eq. 10) that keeps the Schur complement sparse under block-diagonal multi-env assembly, so parallel-env scaling collapses to standard sparse linear algebra primitives rather than hand-written kernels. Datapoint that the hand-built single-domain simulator still beats general-purpose multi-physics platforms (Genesis, Isaac Sim) on fidelity+throughput for the specific slice (contact-rich deformable manipulation) where general simulators have known failure modes.
  • [2026-10-06] OCBench — A Controllable Robotic Manipulation Benchmark for BC and RL: OCBench ships 28 MJWarp-accelerated manipulation tasks × 8 variants (lite/cpu/visual) with Hermite-spline scripted “oracle” policies that mimic human-demo properties (non-Markovian, smoothly random, narrowly distributed), filling the “infinite controllable scripted data” slot opposite real-hardware eval surfaces.
  • [2026-10-06] OpenRUA: Robot-Use Agents Are Zero-Shot Visuomotor Policies: OpenRUA (Chu et al., UCL + CMU) reports the sharpest filed harness-level number on CaP-Bench to date (99.0% with Claude Code + Opus 5) and 87.0% on LIBERO-PRO under a zero-abstraction interface — ROS 2 CLI + rclpy client library as the only tool. Sibling-but-opposite to RobotUse: Allocating Computation, Context, and Decisions RobotUse (same-day filing, 45% on RoboLab with Main/Subagent/Backend + persistent playbook): both land harness recipes head-to-head on packaged robot-benchmark substrates in the same week, with CaP-Bench + LIBERO-PRO + RoboLab now functioning as a triangulation surface for agent-architecture claims.
  • [2026-10-06] RobotUse: Allocating Computation, Context, and Decisions: RobotUse (SNU) is the first filed harness-level result on RoboLab — 45% task success, +6.7pp over CaP-X — complementing Sid’s use of RoboLab-120 for VLA checkpoint eval. Concrete datapoint that the embodiment-agnostic Isaac Lab task set with composable-predicate verifiers is now being used to compare agent-architecture recipes head-to-head, not just policy-weight checkpoints.
  • [2026-09-30] UserProxyBench: Evaluating LLM User Simulators for Agent Benchmarks and Training: UserProxyBench (Jain & Sandhu) is the first filed benchmark that scores the user simulator inside a τ-bench-family RL environment rather than the agent — introduces User Fidelity Score (UFS), a rubric-based independent metric derived from the benchmark’s private user instructions. Holding the agent fixed at GPT-5.5 across 375 enterprise tasks, proxy choice shifts mean task reward by 15.2 points and 24.4% of “successful” episodes contain a user-spec violation. Sharpens the verifier-cheap / action-expensive assumption on this page: the action side of τ-bench-family envs is itself an LLM whose fidelity is currently unmeasured, and every filed platform in this cluster that uses simulated users (InfTool, AgentOmnia, Toolathlon-GYM’s role-playing spans) inherits this confound. Also identifies a cost–fidelity Pareto frontier across seven proxies.
  • [2026-09-28] EmbodiedSWE: Coding Agents for Long Horizon Dexterous Robotics: EmbodiedSWE-Bench (You et al., Yale/Princeton/Stanford/CMU/UCSD) is the second filed coding-agent robotics benchmark after CaP-X, but scales the same env-as-package pattern (per-task Isaac Lab Dockerized backend, fresh-container grading, agent-authored solve(env) contract) to long-horizon dexterous + deformable tasks (bulb screwing, IKEA table assembly, capsule coffee, banana dicing, T-shirt manipulation, mobile fruit delivery). Adds a sim_gen/ module that RLs the coding agent against verified outcomes on newly generated tasks — closing the loop between task-space bootstrap and agent improvement, and an explicit downstream measurement (VLA sim-only-to-real transfer) that most sibling platforms don’t ship.
  • [2026-09-23] Jiafei Duan — Astra vs Opus 5.5 in MuJoCo Ring Fence sumo, Astra wins in 31 seconds: First filed symmetric two-agent MuJoCo competition eval substrate in this cluster — Jiafei Duan’s Ring Fence pits two Unitree G1 humanoids controlled by frontier LLMs (GPT-6 Astra vs Claude Opus 5.5) against each other with a hard-binary ring-exit termination rule. Distinct from packaged-task-suite instances (RoboLab, RoboCasa365, Genesis, Inspect Robots) in that the “verifier” is a physics-derived boundary check rather than a rubric or predicate, and the eval yields a relative ranking rather than per-task success rates. Same MuJoCo substrate the Automataleague RL sumo policies already use, opening a natural next-step comparison of learned RL policies vs LLM-as-controller on identical arenas.
  • [2026-09-22] MiMo-V2.6: Scaling Reinforcement Learning Towards Self-Improvement: MiMo-V2.6 open-sources curated multi-domain RL task environments with verifiers spanning code (five synthesis pathways: PR+issue, vibe-coding, spec-driven, source-driven, long-horizon), general professional workflows, visual artifacts, and cybersecurity, all with a common reward-reliability pipeline (execution checks + rollout-based audits + adversarial testing + F2P/P2P flakiness detection). Ships alongside an end-to-end RL training framework and a 9B distilled student as a reproducible substrate for agentic RL research.
  • [2026-09-10] Introducing Auto-Engineering for Robotics: GRID’s World Experience Harness treats simulation itself as an engineering variable — the agent selects, combines, and extends physics solvers, renderers, sensor models, and backends per task rather than committing to a single simulator. Illustrated by a DFSPH fluid solver (NVIDIA Warp) coupled to MuJoCo rigid-body dynamics for a pouring task, plus warehouse arm + simulated PLC + Gaussian-splat scene imports + deformable-object physics as additional recombinable substrates. Adds an “assembled-per-task hybrid sim” position distinct from the fixed-simulator instances (Isaac Lab, Genesis, RoboCasa365, MJWarp) already on file.
  • [2026-09-05] metal-arm-harness — Arm-agnostic coding-agent harness for MakerMods Metal (Isaac Sin): Second filed “coding-agent-drives-real-arm” harness after Inspect Robots — deliberately narrow instead of broad (one arm family, one bench-tuned safety envelope, single motion primitive, fixed reply schema of joint angles + table clearance + tool-tip pose + one JPEG per camera). Ben’s Slack contrast: “more opinionated, more info per step” vs Inspect Robots’ “easier to run”. Ships a --backend sim mode so the operator session, IK, controller, and envelope all run in CI with no hardware; a table-touch calibration ritual measures the floor physically, and the pre-actuation envelope rejects any waypoint that would come within 10 mm of it. Fable 5.1 zero-shot pick-and-place in ~15 min per Isaac Sin’s launch tweet.
  • [2026-09-05] Jay Chooi (Robocurve) — Astra vs Fable 5.1 on real-robot manipulation via IK: Fresh Inspect Robots evaluation of Astra vs Fable 5.1 on real YAM arms — 120 rollout traces (transcripts, camera recordings, trajectories) released publicly.
  • [2026-09-04] GraspXL: Generating Grasping Motions for Diverse Objects at Scale: GraspXL (ETH AIT, ECCV 2024) uses RaiSim as the RL substrate for dexterous grasp policy training, with a two-phase curriculum (stationary-object precision → non-stationary-object stability) and objective-driven PD-controller-bias wrist guidance. Demonstrates a physics-simulation-only recipe scaling to 500k+ Objaverse objects × 4 dexterous hand morphologies without any 3D hand-object interaction dataset, contrasting the imitation-learning-substrate positions on this page. Released datasets + RaiSim environment configurations for the tabletop + free-approach settings across MANO, Allegro, Shadow.
  • [2026-09-04] Legion — Elixir-native framework for building runtime AI agents: Legion (Software Mansion Labs, open source) is orthogonal to the training-env-fleet pattern this page tracks but shares its core design principle at the deployment runtime layer: per-action sandbox with time and memory budgets, restricted execution language (Lua by default via a pure-BEAM VM), explicit tool-allowlist as the only path out, telemetry on every eval and every generated line of code. Sits closer to a “run the trained agent in production, safely” runtime than to SETA / Toolathlon-GYM / OpenReward (training) or ENPIRE / RoboArena (real-hardware eval) — but the verifier-cheap / action-expensive asymmetry is inverted: here actions are cheap (Lua evals on the BEAM) and “verification” is developer-authored tool code, not test-pass ratios.
  • [2026-09-02] Training frontier knowledge work agents: A 397B RL training guide with SkyRL: Mercor’s 397B RL post-training guide is a full production-scale instantiation of the per-task dockerized backend pattern: each APEX-Agents world ships as an image.tar pushed to ECR, Modal pulls it at trial time to boot a sandbox running MCP servers (Docs/PDF/Email/Chat) over the world’s filesystem; the training-side (SkyRL fully-async loop, vLLM engines, in-flight NCCL weight sync) runs on a Ray GPU cluster where each trial is its own Ray task. Notable operational findings: LLM-judge API keys must be round-robined at 800+ concurrent rollouts, each agent loop must run as its own Ray task (isolated MCP clients), and driving non-model error rate to near-zero via a full evaluation pass at target concurrency is treated as a prerequisite before starting RL — sharpens the platform-side of the “de-risking before compute” argument.
  • [2026-09-01] Reef — Continual Learning Infra for Self-Improving Agents: Reef (Human-Agent-Society, Apache-2.0) is the first filed live-serving continual-learning backend in this cluster: a single reef serve daemon exposes OpenAI/Anthropic-compatible chat endpoints plus a /reef/report feedback endpoint, with x-reef-agent-record-id receipts binding reports to interactions and per-scenario recipes producing weight (SAO / OpenClawRL / TTTD) or harness (SkillClaw / harness_evolve) updates that only publish if they beat the current version. Closes the serve/train loop the env-as-package cluster (SETA, Toolathlon-GYM, OpenReward, HUD.ai) leaves to the operator by putting versioned artifact management and live-swap infrastructure on the same process.
  • [2026-08-31] Microduck Sim 2 Real: Microduck Sim2Real demo montage — real-robot behaviors (walking, standup, forward-roll, roller-skating) trained end-to-end via the microduck_rl mjlab + PPO stack, validating the BAM-actuator + DR sim2real recipe on sub-1 kg humanoid hardware.
  • [2026-08-31] Microduck RL — RL training environments for a ~800 g open-source bipedal robot: Microduck RL — Pollen Robotics releases a full mjlab (MuJoCo Warp) + PPO training stack for a ~800 g, 14-servo open-source biped, with 13 task families (walking, fall recovery, standup, roulade, ball-kick, roller-skating variants) sharing a 61-dim observation contract for runtime policy hot-swapping.
  • [2026-08-29] Inspect Robots — An Open-Source Evaluation Framework for Physical AI (Robocurve): Inspect Robots (Robocurve, MIT) formally open-sources the harness code underneath the three prior Chooi/Robocurve real-hardware tweets (Claude Opus 5 driving robot arms zero-shot via Inspect Robots (Jay Chooi / Robocurve), Gemini Robotics-ER 2 vs Claude Opus 5 clapboard eval — ER2 threw robot arms off table, hallucinated success (Robocurve / Jay Chooi), Gemini 3.7 Flash saturates Robocurve physical tool-use benchmark at 92% vs 32% for 3.6 Flash (three weeks apart)), with Robocurve itself announced as a Public Benefit Corporation the same day. Explicitly modeled on Inspect AI’s LLM eval harness: Task = scenes + controller + scorer, plugin-registered Policy × Embodiment two-slot inputs with fail-fast compatibility check before actuation, immutable schema-versioned EvalLog per run with .rrd Rerun stream attached. Six real-robot embodiment plugins ship on day one (YAM, Franka FR3/Panda, AgiBot A2, Unitree G1, SO-ARM100/101, WidowX 250S) plus Isaac Lab, ROS-bridge, and a dependency-free CubePick mock; policy plugins cover 40+ XPolicyLab-served VLAs, frontier LLMs via --policy agent, and CaP-X code-as-policy (SAM3 + Contact-GraspNet + Pyroki). First filed open-sourced substrate in this cluster whose target is real hardware, complementing SETA (terminal), Toolathlon-GYM (MCP workflows), and OpenReward (managed service).
  • [2026-08-28] LeRobot demos Claude Code operating SO-ARM101 zero-shot via Anthropic MHS — self-calibration to 4.1mm accuracy: LeRobot ships SO-ARM101 as an MHS driver for Claude Code — hardware exposed with read/write primitives + natural-language tags, promised open-source release forthcoming; a shipping-side counterpart to benchmark harnesses like Robocurve.
  • [2026-08-27] CARGO: Physical AI for Industrial Package Stacking: CARGO relies on a proprietary microsecond-per-step 3D bin-packing simulator that validates stability + hardware feasibility inline; treated as the load-bearing scaling axis (40M actions per run), a datapoint that task-specific analytic sims can still be a competitive substrate against general-purpose engines when the task is narrow.
  • [2026-08-27] Previewing the Model Hardware Standard: Anthropic’s Model Hardware Standard (MHS) research preview generalizes the “packaged, distributable agent-interaction interface” pattern from digital eval environments to physical hardware — a model-agnostic, harness-agnostic driver spec with read/write primitives, natural-language device tags, and MCP/CLI/API access surfaces for lab instruments and manufacturing equipment; deployment protocol rather than benchmark, but shares the “standardized interface as the substrate that unlocks agent operation” thesis with Toolathlon-GYM, OpenReward, OSGym, and DimOS.
  • [2026-08-27] Navigator n2: Frontier Computer Use at a Fraction of the Cost: Yutori’s private computer-use environment fleet (>10,000 tasks across hundreds of applications, spanning Linux/macOS/Windows) is the closed-source frontier analog to OSGym’s open OS-replica infrastructure — same design principle (full-desktop replicas with per-task programmatic or LLM-rubric verifiers), but with continuous curriculum refresh where solved tasks demote from RL to SFT and newly surfaced failure modes promote from SFT to RL. Ships a 27B model with OSWorld-Verified 85.3 as evidence the private-fleet + recursive-data-generation recipe reaches frontier at this parameter scale.
  • [2026-08-27] Project SuperDex — A unified simulation platform for dexterous manipulation: Project SuperDex (Meta) is a four-layer open-source dexterous-manipulation simulator (Physics / Robotics / Studio / Lab) with a Gymnasium-compatible RL interface and Ray/RLlib integration in early preview — Meta’s entry into the same design space Genesis World and Isaac Lab occupy, differentiated by a nonlinear-optimization solver shared across forward dynamics and IK, and a Studio authoring tool with SolidWorks/NX CAD-exporter plugins. Landing page only; no benchmarks, throughput numbers, or code links surfaced.
  • [2026-08-20] Binh ports PhysX to AMD Radeon and wins the global AMD robotics hackathon: First filed datapoint that the CUDA-only PhysX GPU solver — the rigid-body core underneath ManiSkill / Isaac Gym / Isaac Lab, i.e. essentially every GPU-physics RL platform on this page — can be ported to AMD Radeon inside a hackathon timeframe. ManiSkill Franka PushCube on W7900 reaches 67,320 steps/s vs 110,705 on RTX5090 at 4096 parallel envs (1.67× gap, attributed to the 5090’s 2× memory bandwidth), and the SO-Frame Sim2Real pipeline reproduces end-to-end with successful real-rig transfer. Won the AMD Radeon 2026-07 robotics hackathon (Track 3). Not yet a third-party-replicated result, but suggests env-compute fleets don’t have to remain homogenous NVIDIA — relevant to the “decouple env compute from training compute” cost model.
  • [2026-08-18] Gemini 3.7 Flash saturates Robocurve physical tool-use benchmark at 92% vs 32% for 3.6 Flash (three weeks apart): Third Inspect Robots real-hardware eval from Robocurve — Gemini 3.7 Flash vs 3.6 Flash on a “cover a block with a towel” task, 5 rollouts each, 0-100 partial-credit rubric. 3.7 averages 92 (4/5 perfect) vs 3.6’s 32 (0-50 range), with per-turn latency halving (17.5 s → 9.0 s). First filed external quantitative measurement of a 3-week frontier-LLM API refresh delivering a real embodied-capability jump, and the moving-target counterpoint to the July 31 ER-2 clapboard failure.
  • [2026-08-10] SimToolReal: An Object-Centric Policy for Zero-Shot Dexterous Tool Manipulation: SimToolReal shows procedural sim generation (handle + head cylinder/cuboid primitives with randomized dimensions and independent densities) is a sufficient training substrate for zero-shot real-world dexterous transfer, when paired with SAPG (population-based PPO variant to escape exploration bottlenecks in massively parallel sim) and asymmetric actor-critic. Also releases DexToolBench: 24 tool-use tasks × 12 tools × 6 categories with paired RGB-D videos and digital-twin sim environments.
  • [2026-08-08] AI Sapiens Open Source — ROBOTIS Docs Directory: ROBOTIS’s AI Sapiens docs page names cyclo_lab as the sim + reinforcement-learning entry point for policy training on the K1 humanoid, alongside URDF and MuJoCo robot-description assets.
  • [2026-08-07] Cyclo — ROBOTIS Open-Source Modular Physical AI Framework: CYCLO’s cyclo_lab sub-module is ROBOTIS’s simulation + reinforcement learning layer inside the broader Cyclo Physical AI framework — a hardware-vendor-owned sim/RL environment that targets the same actuator + robot line the deployment stack (cyclo_control) runs on, keeping sim and real-hardware interfaces aligned by construction rather than by post-hoc integration.
  • [2026-08-06] VISTA: A Visual Harness for Reasoning in an Interactive World: Third filed harness-uplift datapoint on ARC-AGI-3 (after Schema and OpenAI’s Responses-API blog): Opus 5.0 driving VISTA reaches 100.00 mean RHAE on the 25-game public set, self-reported. Sharpens the verifier-cheap / action-expensive design assumption of the benchmark: VISTA never builds a verifier — it just makes read-only inspection of past frames free under the scoring protocol, and that alone (plus free-form language reasoning) suffices to move Claude Opus 5.0 from the ~30% ARC-Prize-protocol baseline to a perfect public-set score. Self-reported, no semi-private / private measurement.
  • [2026-08-04] Assemble Benchmark — DAgger with Code-as-Policy (HUD.ai): HUD.ai’s Assemble blog post announces a code-as-policy training recipe on the HUD managed RL-environment platform that reportedly applies DAgger (expert relabels states the student visits) rather than the GRPO/PPO recipes dominant across the other filed platforms — the first filed datapoint in this cluster using imitation-with-aggregation instead of outcome-verified RL. Filed from a Slack pointer without full content retrieval (429 at ingest); a /bud refresh is warranted once the article is reachable.
  • [2026-08-04] AgentOmnia: Scaling Agentic Models for Full-Scenario Applications: AgentOmnia ships 5,018 stateful environments with 255,375 tools tied to program/solver/verifier correctness signals — env infrastructure fully in-house rather than shipped as a public package, wired directly into a Difficulty × Capability curriculum.
  • [2026-08-03] Robot-eval-bench: Benchmarking Task Success Evaluation for VLMs: Kite ML’s Robot-eval-bench positions the auto-eval-in-simulation loop (generate varied worlds → run policy → VLM judge scores every rollout) as the alternative to human-with-spreadsheet real-hardware grading, and quantifies which frontier VLMs make trustworthy judges — data, code, ground truth, cost model open-sourced.
  • [2026-07-31] Gemini Robotics-ER 2 vs Claude Opus 5 clapboard eval — ER2 threw robot arms off table, hallucinated success (Robocurve / Jay Chooi): Second Inspect Robots eval from Robocurve — head-to-head Gemini Robotics-ER 2 vs Claude Opus 5 on a YAM-arm clapboard task, 5 rollouts per model, binary success + qualitative failure-mode labels (hallucinated success, hardware damage). Establishes the per-rollout video-diagnostic format for the real-hardware slot in the env-as-package cluster and produces the first filed neutral-third-party number on Gemini Robotics-ER 2 specifically.
  • [2026-07-29] Tacmap: Bridging the Tactile Sim-to-Real Gap via Geometry-Consistent Penetration Depth Map: Tacmap (Sharpa + HKUST + NVIDIA) extends the tactile-front-end category alongside Tactile Genesis: Exploring Tactile Sensors at Scale for Learning Dexterous Tasks but bets on a single-abstraction commitment: geometry-consistent penetration-depth (“deform map”) computed by GPU ray-casting inside Isaac Lab’s Raycaster API (and MuJoCo’s mjray) at RL-relevant parallelism — memory scales near-linearly to 8,192 parallel envs and enabling tactile rendering yields negligible throughput hit, because the ray-cast pipeline is vectorised alongside the physics step rather than run as a separate FEM stage. Sim-to-real closed by a ResNet encoder-decoder that inverts real tactile images back into the same geometric quantity, validated by zero-shot PPO transfer of an in-hand rotation policy to the SharpaWave hand. Adds the “commit to one geometric abstraction and align both domains to it” design axis to the tactile-simulator sub-cluster, complementing Tactile Genesis’s “expose eight abstractions under a common interface” bet.
  • [2026-07-29] Netherite — Minecraft 1.11.2 rewritten in C/CUDA, bit-verified against Java, 7,200 parallel worlds on one GPU: Netherite (Elliot Arledge) opens a new axis in this cluster — collapse action cost by rewriting the simulator against the training hardware rather than eating it as Docker sandboxes (SETA / Toolathlon-GYM) or offloading to a separate GPU pool (Anyscale + Isaac Lab). A C + CUDA reimplementation of Minecraft 1.11.2 with bit-exact CPU↔CUDA ticks, 23/23 input-tape replay against Java Minecraft, 3.0M env-ticks/s at N=8192 batched worlds, and a stripped 64×36 block-ID observation for training; positioning is explicitly “train here, replay in Java, get the same result.” Same design bet as Genesis World — Simulation platform for general-purpose robotics & embodied AI learning made for robotics, applied to Minecraft — and the throughput substrate the sibling Pantograph introduces Pan-1 — Minecraft model with RL-based pretraining, arguing video games are the right testbed for robotics Pan-1 argument was implicitly asking for. Systems numbers are self-reported and no third-party replay exists yet.
  • [2026-07-29] 3 Billion Expert Transitions Across 11 Million Physics-Based Tasks (Kinetix-Offline): Kinetix-Offline (FLAIR / Oxford) extends the env-as-package pattern with a pre-computed offline data substrate at unprecedented scale: 3B expert transitions across 11M procedurally-generated 2D physics tasks (326 GB), collected via per-level PPO specialists that save only successful trajectories. Raw environment state is stored rather than pre-rendered frames, so downstream training swaps observation modality (pixel vs symbolic) and can restart evaluation from any point in a trajectory. First filed instance in this cluster whose distinguishing contribution is the offline dataset, not the sim or the verifier.
  • [2026-07-29] WorldModelGym: a decision-based fidelity benchmark for world models: WorldModelGym (Reka Labs) extends the env-as-package pattern to learned world models as the thing being scored: a Gymnasium-contract step extension where the environment adapter is the submitted model (JEPA latents / tokens / pixel video-diffusion states all opaque to the evaluator), and 100+ declarative-file tracks across Atari / Meta-World / DMC / classic control. Verifier-cheap / action-expensive design inverted from the usual pattern — action cost here is the WFM’s own rollout compute, not Docker sandbox setup — and open-loop multiple-choice ranking replaces full-horizon rollouts to keep pixel WFMs tractable. First filed platform that puts learned world models behind the Gymnasium contract rather than using simulators to train/evaluate policies.
  • [2026-07-28] CausalGame: Benchmarking Causal Thinking of LLM Agents in Games: CausalGame extends the env-as-package pattern to causal-reasoning diagnosis of AI-Scientist agents: 14 game scenarios with hard-coded ground-truth causal DAGs plus injected selection bias / measurement error / hidden confounders, so both the analytical optimum and the process-level rubric are automatically computable. Differs from Toolathlon-GYM / SETA / OpenReward on grading axis: outcome (“survival”) + explicit process rubric on the agent’s causal explanation, not just end-to-end task completion. Reported 5–7% rubric credit across 30 models is the first filed process-grade result on this kind of platform.
  • [2026-07-27] RoboLab — Task-Based Evaluation Benchmark for Robot Manipulation Policies on Isaac Lab (NVLabs): RoboLab (NVLabs, RSS 2026 — Yang, Dagli, Zook, Hadfield, Goyal, Birchfield, Ramos, Tremblay) extends the env-as-package pattern to embodiment-agnostic Isaac Lab manipulation: 120 initial tasks (RoboLab-120) spanning pick-and-place, stacking, rearrangement, and tool use, each with language instructions and automated success/failure detection via composable predicates. Tasks are not tied to a specific robot arm (any IsaacLab-compatible robot plugs in), the policy under test runs as a separate HTTP inference server the eval client calls each step, and two Claude Code skills (/robolab-scenegen, /robolab-taskgen) generate new scenes and tasks from natural language. Ships a self-contained web dashboard for cross-experiment comparison and video replay. Reported throughput ~30 GPU-hours per 100 tasks (Sid’s Slack context confirms 4-5 hours per VLA checkpoint on the full 120-task set). Complements the sim + real RoboDojo: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies and the kitchen-domain RoboCasa365 — Large-Scale Simulation of Everyday Tasks for Generalist Robots as the third Isaac-family sim-eval leaderboard filed this year — RoboLab’s differentiator is embodiment-agnostic tasks + AI-authored extension of the task library.
  • [2026-07-27] RW-RL Dataset: Real-World Reinforcement Learning for Robots: RW-RL Dataset ships the offline data-substrate half of the SJTU MINT + Boden + Junpu real-world RL platform, paired with Evo-RL: Open Real-World Offline RL on SO-101 and AgileX PiPER as the online loop — a real-robot data infrastructure stack (BRIC Robo / BASE Omni / Blink) plus a validation loop where autonomous rollouts feed back for the next policy iteration. Concrete counterpart to the sim-first RL environments on this page for RECAP-style on-hardware training.
  • [2026-07-25] Claude Opus 5 driving robot arms zero-shot via Inspect Robots (Jay Chooi / Robocurve): Inspect Robots (Robocurve, MIT) extends the env-as-package / evaluation-harness pattern from terminal (SETA), enterprise-workflow (Toolathlon-GYM), and managed sandboxes (OpenReward) to real hardware for VLA / physical-AI models; announcement tweet demonstrates Claude Opus 5 zero-shot on two tabletop manipulation tasks with a promised frontier-LLM-vs-VLA report to follow.
  • [2026-07-22] LeRobot Sim-to-Real Tutorial — 72% real-SO-100 success from LuckyEngine sim demos only: LuckyEngine (MuJoCo + Vulkan, C# scene scripts, Python gRPC SDK) paired with Genesis as a sim-to-sim generalization probe — a two-simulator workflow where the second sim serves as a cheap real-world proxy before touching hardware.
  • [2026-07-20] Danfei Xu — two root-level paradigm shifts in robot learning: Sim2Real for locomotion, Behavior Cloning for manipulation: Danfei Xu casts Sim2Real (for locomotion) as one of only two root-level paradigm shifts of the deep-learning era in robot learning — an implicit endorsement of simulator platforms as the load-bearing substrate for that sub-field.
  • [2026-07-16] Schema — Frontier Models with Our Harness Achieve ~99% on ARC-AGI-3 Public: Schema is the first filed harness result on ARC-AGI-3 (the concept’s most demanding filed environment): self-reported 98.98% Public RHAE with Opus 4.8 / Fable 5 fallback versus 42.83% for the same pair under unconstrained Claude Code, isolating a 56.15% harness effect. Sharpens the verifier-cheap / action-expensive design pattern: here the learned world-model program is the verifier and BFS inside it substitutes for environment actions; residual failures are 5-6 games where representation discovery, not verification, is the bottleneck.
  • [2026-07-15] Pantograph introduces Pan-1 — Minecraft model with RL-based pretraining, arguing video games are the right testbed for robotics: Pantograph explicitly argues Minecraft-class video games are the right RL testbed for robotics methods (reproducible / safe / open-ended / long-horizon) — treating game environments as first-class robotics-adjacent RL platforms rather than just eval curiosities. Product-tweet framing; Pan-1 launch is the first datapoint attached to this argument on the wiki.
  • [2026-07-14] Tactile Genesis: Exploring Tactile Sensors at Scale for Learning Dexterous Tasks: Tactile Genesis (Chung et al.; NSF/DARPA/Amazon/CMU/Google-supported) extends the env-as-package pattern with a tactile front-end integrated into Genesis World — 8 sensor abstractions (contact / depth / kinematic force-torque / elastomer / proximity / temperature / audio) under one interface, 20,000+ parallel envs and 1,000+ taxels on a single GPU, 3-20× throughput over TacSL / Tacmap / HydroShear / FOTS. Turns “sensor hardware ablation” from a hardware-swap-per-lab problem into an in-simulator sweep, and validates the resulting placement-over-type design directive with sim-to-real transfer on a real XHand1.
  • [2026-07-14] How Claude Performs on Robotics Tasks: Anthropic assembles a mixed sim-and-real evaluation harness on top of Mujoco (classic control + Go2/G1 locomotion), LIBERO kitchen scenes (direct + VLA-supervised manipulation), and a physical Unitree Go2 for real-world navigation. Introduces TwinFlipper as a novel chaotic-dynamics classic-control task explicitly designed to avoid pretraining-corpus contamination (unlike inverse pendulum and hopper), and an eleven-task Go2 navigation suite with self-monitoring probes (drift_detection: notice commands are being silently corrupted; explore_report: answer layout questions from memory). Sim runs are paused between LLM calls to approximate an upper bound on capability by removing real-time latency — the paper quantifies the gap: ~83 Hz needed vs 0.2–0.4 Hz non-reasoning inference, roughly two orders of magnitude. Complements the packaged-env pattern (SETA, Toolathlon-GYM, RoboCasa365, RoboDojo) with a frontier-lab safety-evaluation framing where the environment is instrumented specifically to measure LLM-as-controller capability trends across model generations.
  • [2026-07-14] GaP: A Graph-as-Policy Multi-Agent Self-Learning Harness For Variational Automation Tasks: GaP (Berkeley/NVIDIA/CMU; Goldberg, Fan, Zhu) extends the CaP-Gym env-as-package pattern with a parameterized simulator that spins up per-candidate-graph instances for parallel rehearsal, with pre/post-node state and contact feedback logged at every node boundary for failure localization. Ships 8 new Variational Automation benchmarks (4 sim, 4 real — grocery fulfillment, grocery packing, popcorn, USB-C insertion, bimanual crate washing) explicitly designed with larger pose/geometry variation than LIBERO/LIBERO-Pro; the sim table pairs each benchmark with per-instance randomization of object poses and arrangements.
  • [2026-07-14] ABot-AgentOS: A General Robotic Agent OS with Lifelong Multi-modal Memory: EmbodiedWorldBench (companion benchmark to ABot-AgentOS, Alibaba): 16 indoor/outdoor/hybrid scenes × 4 difficulty levels × 200+ tasks spanning navigation, object search, NPC dialogue, dynamic events, with trace-grounded scoring rather than terminal-state scoring — targeted at long-horizon embodied agent OS evaluation.
  • [2026-07-09] RoboDojo: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies: RoboDojo (HKU MMLAB + Berkeley) unifies the sim and real halves of the env-platform pattern: 42 Isaac Sim tasks partitioned across 5 capability dimensions (generalization, memory, precision, long-horizon, open-vocab) plus 18 real tasks on cloud-remote standardized hardware (RoboDojo-RealEval), with XPolicyLab as a common policy-integration layer; ships a public leaderboard from a 30-policy sweep — the largest filed policy pool on a single manipulation benchmark, complementing RoboArena’s real-only crowd-sourced protocol and RoboCasa365’s sim-only kitchen suite.
  • [2026-07-05] Agent² RL-Bench: Can LLM Agents Engineer Agentic RL Post-Training?: Uses ALFWorld / WebShop / DeepSearchQA as packaged environment substrates but flips the evaluated agent: instead of measuring an RL-trained policy inside the env (the concept’s usual pattern), it measures whether a CLI coding agent can engineer the training pipeline (data, rewards, rollout collection, GRPO/DPO/PPO code) that would produce such a policy. Behavioral instrumentation records every submission and code revision inside the workspace — adds a “how the agent constructed the pipeline” observability layer on top of the standard verifier-cheap / action-expensive env-as-package design.
  • [2026-07-04] RoboWorld: Fast and Reliable Neural Simulators for Generalist Robot Policy Evaluation: RoboWorld turns a single real initial frame into an interactive neural simulator and runs closed-loop VLA policy evaluation with no simulator engineering or asset creation, including eight extreme unseen-scene variants of RoboArena episodes.
  • [2026-07-01] Scale Robot Policy Evaluation with Ray (Distributed Sim-Eval on Anyscale): Anyscale’s engineering post lays out a Ray + Anyscale reference architecture for large-scale robot-policy evaluation: policy (GR00T-N1.7-3B) as an autoscaling Ray Serve deployment on one GPU pool, Isaac Lab simulators as isolated Ray tasks on a separate GPU pool, HTTP boundary between them, action-chunk amortization (action_horizon = 8 steps per ~1.6 s inference) across the hop; standardizes the rollout runtime the way SETA/Toolathlon-GYM/OpenReward standardize the task side and RoboArena/RoboCasa365/Genesis standardize the evaluation substrate — same verifier-cheap/action-expensive design principle where action cost is GPU physics + rendering rather than Docker sandbox setup.
  • [2026-06-30] ASPIRE — self-evolving sensorimotor skill library that compounds across robots and the sim-to-real gap (Jim Fan / NVIDIA GEAR): Jim Fan announces NVIDIA GEAR’s ASPIRE — a sim+real co-training setup where coding agents run evolutionary search over control programs against multimodal sensory traces from both simulated and real robots, with successful programs distilled into a self-evolving code skill library. Full stack promised as open-source alongside a gallery of 150+ tasks and 90+ self-taught skills.
  • [2026-06-29] CHORD: Object-Centric Contact Wrench Guidance for Dexterous Manipulation: CHORD ships a 4,739-task simulation-ready bimanual dexterous manipulation benchmark constructed from mocap datasets and reconstructed in-house human videos, paired with the demonstrations themselves — the largest filed dexterous-RL task surface and a direct answer to the “where do dexterous RL environments come from at scale” gap.
  • [2026-06-29] SimFoundry: Modular and Automated Scene Generation for Policy Learning and Evaluation: SimFoundry reconstructs deployable simulation environments from a single video, with cousin-style automated augmentation along object / scene / task axes — a user-supplied real scene → on-demand parameterized sim environment pattern complementing RoboCasa’s fixed kitchen-task benchmark and Genesis World’s general-purpose simulator.
  • [2026-06-24] Qwen-AgentWorld: Language World Models for General Agents: Qwen-AgentWorld is the strongest filed counter-bet to the env-as-package design pattern: instead of shipping environments as Docker stacks (SETA, Toolathlon-GYM) or managed services (OpenReward) or synthesizing executable SQL-backed environments (AWM), train a single MoE LLM (35B-A3B / 397B-A17B) to simulate environment dynamics across 7 agentic domains via long CoT reasoning. Reports that this simulator scales to thousands of environments controllably and yields agentic-RL gains exceeding real-environment training alone. Inverts the verifier-cheap / action-expensive assumption: when the simulator is a learned model, both verifier and action become cheap inference passes.
  • [2026-06-20] Playful Agentic Robot Learning: RATs reuses LIBERO-PRO and MolmoSpaces (the same env-as-package artifacts CaP-X: A Framework for Benchmarking and Improving Coding Agents for Robot Manipulation benchmarks against) but flips the role: the env is now a play substrate for skill-library acquisition rather than a downstream evaluator. Verifier-cheap + action-expensive design extends to a setting where rollouts are exploratory and the verifier scores intermediate progress, not just final task success — adds a new use-case axis (skill discovery) alongside policy-fitting and evaluation.
  • [2026-06-17] ABC: Scalable Behavior Cloning with Open Data, Training, and Evaluation: ABC Sim extends the env-as-evaluation-substrate pattern (Genesis World, RoboCasa365) to bimanual manipulation: MuJoCo physics + an offline Blender re-rendering pipeline for higher-fidelity ray-traced frames, 400h of sim-teleop across 20 tasks. Headline contribution to this cluster is a quantified sim-real correlation study across 12 paired checkpoints (r=0.85 strict success, r=0.91 task progress) — the second filed datapoint after Genesis (Pearson 0.8996) supporting the “use sim purely as cheap eval, decouple from training” thesis.
  • [2026-06-16] ENPIRE: Agentic Robot Policy Self-Improvement in the Real World: ENPIRE extends the verifier-cheap / action-expensive env-as-package pattern from terminal and enterprise-workflow surfaces to physical manipulation: each task is wrapped as self-resetting (randomized initial state + reset behavior + verification of reset success) and self-verifying (multi-camera detector + segmentation fused into a binary reward), with the auto-reset + multi-camera verifier playing the role the Docker sandbox plays in SETA / Toolathlon-GYM; also supplies simulation evaluation in RoboCasa as the parallel sim track.
  • [2026-06-14] LEGS: Fine-Tuning Teleop-Free VLAs for Humanoid Loco-manipulation in an Embodied Gaussian Splatting World: LEGS is a hybrid MuJoCo + 3DGS simulator with a procedural Walk → Pick → Place motion-primitive generator that emits verified-success-only labeled demonstrations — a humanoid-loco-manipulation analog to RoboCasa365’s auto-trajectory pipeline but with photorealistic 3DGS backgrounds replacing meshed kitchens.
  • [2026-06-14] RoboArena rolls back evaluations after benchmark hacking observed since April (Pranav Atreya announcement): First filed integrity-attack datapoint on any platform in this cluster — RoboArena lead author Pranav Atreya publicly announces that benchmark hacking has been observed on RoboArena since April 2026, that mitigations are now in place, and that affected evaluations (including, per the Slack pointer, NVIDIA’s Cosmos) have been rolled back; the §3 “robustness against single-actor manipulation” property of RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies survived only because the maintainer team detected the attack out-of-band, not because the protocol caught it automatically.
  • [2026-06-08] RoboArena: Distributed Real-World Evaluation of Generalist Robot Policies: RoboArena (CoRL 2025) is the real-world / human-evaluator counterpoint to the standardized env-as-package pattern — instead of a fixed task set with an automatic verifier, evaluation is crowd-sourced across seven academic institutions on the DROID platform, with double-blind pairwise A/B comparisons aggregated by a task-aware Bradley-Terry extension; a 1:1 evaluation-credit system balances supply and demand. At matched episode budget across 612 paired comparisons over 7 generalist DROID policies, the crowd-sourced ranking matches a 4,284-episode oracle ranking more accurately than the conventional centralized 17-task DROID protocol — direct evidence that the “verifier-cheap, action-expensive” design assumption (Docker sandbox + unit tests) breaks for embodied generalist policies where the deeper signal lives in unstandardized real-world conditions a human judge can resolve.
  • [2026-06-08] RoboCasa365 — Large-Scale Simulation of Everyday Tasks for Generalist Robots: RoboCasa365 — ICLR 2026 release of a kitchen-domain manipulation env platform with 365 LLM-authored tasks, 2,500+ scenes, 3,200+ objects, and 2,200+ hours of human+auto demos. First filed manipulation-specific entry in the env-as-package pattern, with built-in Diffusion Policy / pi0 / GR00T baselines and a public leaderboard. The 600h-human + 1,600h-auto demo split mirrors SETA’s frontier-synthesizes-tasks pattern on the trajectory side.
  • [2026-06-03] Project Chrono — Open-Source Multi-Physics Simulation Engine: Project Chrono — long-running open-source multi-physics simulator covering rigid-body, FEM, granular, fluid-solid, and ODE dynamics with a ROS2-integrated camera/LiDAR/GPS/IMU/SPAD sensor suite. Predates the recent wave of pip-installable robotics platforms and is the closest C++ analog to Genesis World.
  • [2026-06-01] Genesis World — Simulation platform for general-purpose robotics & embodied AI learning: Open-source physical-robotics environment platform (Apache 2.0): unified multi-physics scene API + multi-embodiment support (Franka, Go2, humanoid, drones), heterogeneous parallel simulation, broad sensor suite (RGB, depth, lidar, tactile, IMU, contact, temperature). First filed RL env platform whose underlying simulator is itself a research artifact, not a thin wrapper around an existing engine.
  • [2026-06-01] The Role of Simulation in Scalable Robotics, Genesis World 1.0, and the Path Forward: Genesis World 1.0 extends the env-as-package pattern to physical robotics — Apache 2.0 stack (physics + renderer + compiler) framed primarily as the evaluation substrate, with sim-to-real correlation (Pearson 0.8996) as the trust metric and a perturbation-axis taxonomy (visual/behavioral/semantic) replacing scalar success rates. Where the existing terminal/coding env entries are verifier-cheap + action-expensive via Docker, Genesis is verifier-cheap + action-expensive via full multi-physics + path-tracing.
  • [2026-05-27] stable-worldmodel: A Platform for Reproducible World Modeling Research and Evaluation: stable-worldmodel — extends the env-as-package pattern from terminal/coding agents to world-model research: bundled environments with controllable visual / geometric / physical factors of variation, plus a Lance-based data layer with LeRobot ingestion. First filed instance applying the standardized-env+verifier discipline to the WFM evaluation surface rather than to RL training.
  • [2026-05-23] OpenReward — 330+ RL Environments through one API (General Reasoning announcement): OpenReward launches as the first managed-platform datapoint — 330+ environments × 4.5M+ tasks behind an HTTP API, ORS protocol extending MCP with RL primitives, autoscaled sandbox compute provisioned per rollout, trainer compatibility announced for Tinker / Miles / Slime. Turns “env-as-package” into “env-as-managed-service” and shifts the quality-control problem from per-env synthesizer to platform-level policing.
  • [2026-05-23] Toolathlon-GYM: Large-Scale Long-Horizon Environments for Tool-Use Agents: Toolathlon-GYM (Eigent.AI + HKUST-NLP + CAMEL-AI) — 503 long-horizon multi-MCP tasks with brand-obfuscated descriptions, 25 MCP servers, 8.2 MB PostgreSQL dump as shared mock backend. Adds the enterprise-workflow surface (Canvas LMS, Snowflake DW, WooCommerce, Yahoo Finance) to a space that previously held only terminal/shell.
  • [2026-05-22] SETA: Scaling Environments for Terminal Agents (env repo): SETA (CAMEL-AI + Eigent.AI + SambaNova) — ~400 Terminal-Bench-compatible tasks auto-synthesized by a Claude-Sonnet-4.5 two-agent factory and validated by Terminal-Bench’s own Oracle agent. First filed instance of the “env compute on a separate AWS fleet” pattern, and a +20.2% Qwen3-8B GRPO lift on the synthetic 260-task subset.

Open questions

Section titled “Open questions”
  • How does task quality scale with a federated, third-party-authored environment catalog (OpenReward) compared to a curated single-team release (SETA, Toolathlon-GYM)? No filed paper measures the quality-vs-scale curve.
  • Does the MCP/ORS abstraction actually let trainers drop a new env in without per-env special-casing, or does it leak enough that GRPO recipes still need env-specific reward shaping? Toolathlon-GYM ships uniform tools, OpenReward claims protocol-level uniformity, but neither reports a “trainer-agnostic” headline number.
  • What is the right granularity for “task” vs “environment”? OpenReward’s 4.5M tasks / 330 envs ratio (≈13.6K tasks/env) implies envs are parameterized task generators, not single tasks; SETA’s ~400 tasks live inside a single env; Toolathlon-GYM’s 503 tasks live across 25 MCP servers. The dataset-vs-env boundary is unclear in the filed material.
  • Where is the RL-recipe ceiling on this kind of training? SETA reports a +20.2% unit-test-pass-ratio lift on a small base (Qwen3-8B) over a small training set (260 tasks). Toolathlon-GYM is dataset-only at filing time. OpenReward is platform-only. No filed result yet pins down the asymptote.
  • How does the “frontier model synthesizes tasks, smaller model trains on them” recipe (SETA) interact with the “third-party authors author the env, anyone trains” recipe (OpenReward)? The two have different incentive structures for env quality and different attack surfaces for synthesizer-bias.
  • Are brand-obfuscated task descriptions (Toolathlon-GYM) sufficient to prevent shortcut behavior in agents that were pretrained on the un-obfuscated versions (Notion / Google Calendar / Snowflake docs)? No filed paper measures this.
  • Does the verifier-cheap-action-expensive design pattern have natural limits — i.e. is there a domain where verifier compute dominates action compute and these recipes invert? Image/video generation evaluation (where a learned reward model is the dominant cost) is the obvious candidate.

Papers

Section titled “Papers”

2026-05

Section titled “2026-05”

2026-04

Section titled “2026-04”

2026-03

Section titled “2026-03”

2026-01

Section titled “2026-01”

2025-12

Section titled “2025-12”

2025-11

Section titled “2025-11”

2025-02

Section titled “2025-02”