reference/robobench/README.md

RoboBench

A benchmark for code-generating agents. It tests whether an agent can few-shot solve long-horizon, complex tasks — multi-step problems where the agent has to write code that plans, manipulates, and recovers across a long sequence of actions, not just emit a single move.

RoboBench is organized as a growing family of suites, each a different flavor of hard task (robot furniture assembly is the first; other flavors — e.g. liquid handling / latte-art benches — can slot in the same way). The simulator backend is deliberately not baked into the design: suites compose the same small set of building blocks regardless of what runs underneath, so new backends and new task families are additive, not rewrites.

This README is the living statement of the building blocks and the design philosophy.

---

Design philosophy

One equation. This is the heart of the design, not a diagram bolted on after:

env  =  scene  +  robot          (+ an optional, hidden verifier)

That's the entire composition. Everything else is detail under those three nouns.

• BaseScene — the object world (the things to manipulate). Embodiment-agnostic; knows nothing about the robot. It also carries the goal (see "No task layer").
• BaseRobot — the actor: the embodiment; its actions flow through a pluggable controller chosen by its control_mode (see below).
• BaseEnv — the open shell that holds the simulation and wires a scene and a robot together. Composition is by injection: build a scene and a robot, hand them to the env. Swapping embodiment = a new env with a different robot.
• BaseVerifier — a privileged, optional, hidden scorer. Not part of the env's contract with the agent; the env runs fine without one.

All four are import-light — they import without spinning up a simulator, so you can list registries, read contracts, and run tests cheaply. Only building a BaseEnv touches the backend (imported lazily).

Registration is import-time, and cheap — because heavy work is deferred. Scenes, robots, controllers, and env-configs register themselves into name→factory registries at import time (a @register decorator or a register_env(...) call runs when the module is imported). So robobench.discover() — which imports every robot, controller, and suite to populate the registries — is all it takes to make everything resolvable by name. That stays ~milliseconds and never launches the simulator only because each module keeps its top level import-light: the expensive work (importing the backend, loading USD, building the scene/robot/sim) is deferred into methods (assets(), build(), to_isaaclab()), never run at module scope. The discipline this demands: when you add a scene/robot/controller, keep heavy imports inside methods, not at module top level — otherwise discovery, and every "just list what's available", slows to a simulator boot.

The env is open, not a sealed box. The agent reaches the simulation, the scene, the robot, the raw asset handles, and the underlying state. It may patch an instance, subclass-and-adopt, or rebuild. Enforcement of "don't cheat" is by prompt, not by access control — ablation dials that restrict access live in the harness (agent/), never in the env.

No task layer — a scene is a task. There is deliberately no Task class / TASKS registry. Each scene is built for one task: it carries its own goal as natural language in scene.describe(), and its success criteria live in an optional BaseVerifier. A task class would just re-wrap the scene's goal and a hidden reward — so it's absorbed into the scene + verifier. (One scene → one task; a variant task is a new scene.)

The verifier is optional, hidden, and outside the agent's loop. While solving, the agent reads the open state and designs and trusts its own success metric — the env hands it no reward, so the task is "solve the goal," not "maximize this number." The BaseVerifier is a separate, privileged scorer that exists for everything around the solving loop: a human (or an automated harness) running large-scale, apples-to-apples evaluation across agents, and producing a reward signal for post-hoc RL / fine-tuning of an agent. Keeping it optional and hidden lets the same scene serve both open-ended exploration and rigorous, comparable scoring — and a scene can ship with none at all (pure sandbox).

Control is a separate, shared, pluggable layer — selected by the robot. A BaseRobot declares the control modes it supports (control_modes, e.g. ("joint", "ee_pose", "osc_impedance")) and which is active (control_mode); the active mode maps the action vector to joint targets, so action_dim follows the mode. But the controller itself is a shared, reusable component — its own module, not baked into each robot: one implementation (joint, end-effector IK, operational-space / impedance, a whole-body solver, or a frozen learned policy) serves many embodiments. A robot just declares its modes and wires each to a controller with its own joints / end-effector / gains. This keeps "swap the controller on the same robot + task" a clean, first-class operation. The env dispatches through self.robot every step (late binding), so a patched/swapped controller — or a custom one via an overridden apply_action — takes effect immediately.

Distinguish a controller from a skill, and the env from the agent. A controller is the per-step action→joint map (the control mode). A skill is a higher-level primitive the agent invokes ("grasp this", "walk to here") that runs many steps through a controller — skills live in the agent layer, not the env. The guiding rule across the whole framework: the env provides what is shared and part of the stable contract (scenes, robots, controllers, the verifier); the agent owns what is the research (its policies, training loops, skill orchestration, curriculum). Provided layers are baselines + seams, never locked — an agent may use a controller, extend it, or replace it.

This is the System 1 / System 2 split now standard in robot foundation models — a fast, reactive low-level policy beneath a slow, deliberative high-level one (Figure's Helix: a 200 Hz reactive S1 under a 7–9 Hz VLM S2; NVIDIA GR00T N1: a high-rate diffusion-policy S1 under a VLM S2, explicitly "inspired by human cognition") — i.e. the cerebellum (fast motor coordination) under the cerebrum (deliberation/planning). robobench splits along the same line: the controller is System 1 / cerebellum — env-owned, fast, per-step — and the skill + agent are System 2 / cerebrum — agent-owned, slow, deliberative. The env provides the fast substrate; the agent owns the slow brain.

Controllers — roadmap (coming, not built yet). The control layer is grown incrementally. First a basic set (joint, then an IK solver); then, as needed: operational-space / impedance, a whole-body solver, composite controllers (different controllers over different DOF groups — e.g. arms by IK + legs by a locomotion policy), a residual-RL wrapper (a learned correction on top of a base controller), and frozen / pure-RL policy controllers. Crucially, training those policies (residual or pure locomotion RL) is the agent's job — done through the env's reward + rollout + snapshot seams; the env only provides the controller slot they plug into.

The base classes are strict contracts. Everything a child must provide is an @abstractmethod, so a subclass that forgets one cannot be instantiated. bind() is the one concrete shared method (caches the env back-ref; children extend via super().bind(env)).

Curriculum is for the agent to drive. The abstractions exist so an agent can cheaply change the problem to debug it — relax physics, disable collisions, or swap the embodiment to make a hard step tractable, then tighten back. And because get_states / set_states can set the env to any state, the agent can jump straight into a not-yet-learned state to debug that phase directly — instead of replaying the whole task from the start to reach it. Making those switches easy to explore is a first-class goal.

Skills transfer across embodiments and across tasks. Because the scene is embodiment-agnostic, the same task can run with a different body — so "same scene, different robot" (and "same robot, new scene") is a cheap swap, not a rewrite. This is deliberate: an agent should be able to carry a skill from one embodiment to another, or from one task to a related one, and few-shot the new case by adapting what it already knows instead of relearning from scratch — and even to characterize what actually differs between two bodies on a simple task.

Batched and RL-ready — so the agent can build its own debug loop. The env runs many copies in parallel and exposes full state capture/restore alongside a plain step loop. When an agent gets stuck on one phase, it can stand up a small RL environment on the spot — treat the (otherwise hidden) success check as a reward, restart from a saved snapshot of the hard phase, and drill just that segment — without leaving the framework or rewriting the env. Writing a controller, scripting a plan, or training a small policy to get past a phase are all just things you can do against the same open object.

---

Contracts at a glance

Class	Children must implement (@abstractmethod)	Concrete on the base
BaseScene	assets · reset · get_state · set_state · describe	bind
BaseRobot	assets · reset · describe (+ hooks on_bind / build_controller)	bind · apply_action · action_dim · get_state · set_state · set_controller · actuator_sink · actuator_limits; declares control_modes / control_mode
BaseController	action_dim · compute · _resolve_joints	bind · apply · reset · get_state · set_state; command_type set at construction
BaseVerifier	verify → Any (structured result TBD)	—
BaseEnv	(not abstract — the shell)	get_states · set_states · reset · step · describe · describe_stage · verify · close

• describe() → curated natural-language string (scene's objects + goal, then the robot). Prompt-ready.
• describe_stage(root=None, raw=False) → the low-level counterpart: structured list[{path, type, pos, size}], or raw=True for the raw scene-graph text.
• get_states() / set_states() → full state = {"scene": ..., "robot": ...}; restore to any saved state (snapshots, replay of hard phases).
• step() / reset() return None — observations are a wrapper concern, not the raw env's.

---

Using it — recipes

Examples assume AppLauncher is running and the registries are populated (import robobench; robobench.discover()), plus an env built as in the first recipe. The env is an open object: patch or swap parts on the live instance — the step loop dispatches through self.robot / self.scene, so changes take effect on the next step().

Build & run an env. Load a registered binding by name, or wire an ad-hoc combo, then step it:

import robobench; robobench.discover()        # populate registries: robots, controllers, suites
from robobench.core import ENVS, EnvCfg

env = ENVS.get("assembly.ikea_table")().build(num_envs=4)          # a registered config, by name
# ...or ad-hoc:  EnvCfg(scene="ikea_table", robot="g1", control_mode="joint").build()
env.reset()
print(env.describe())                                              # NL scene + goal + robot (prompt-ready)
for _ in range(200):
    env.step(action)                                               # action: (num_envs, env.robot.action_dim)

(Or smoke any combo from the shell: python -m robobench.scripts.smoke --list / --env <name>.)

Switch the control mode. Same robot + scene, different actuation — action_dim follows:

EnvCfg(scene="ikea_table", robot="g1", control_mode="pink_ik").build()   # vs "joint"
# or override at build time:  cfg.build(control_mode="pink_ik")

Write your own controller and plug it in. A controller maps an action to a joint command for the DOFs it owns and writes it itself. Subclass BaseController, then drop it onto the live robot with set_controller — it binds and takes effect next step(), and need not be in the robot's control_modes menu:

from robobench.core import BaseController

class ElbowWiggle(BaseController):
    def __init__(self, cfg=None):
        super().__init__(cfg, command_type="position")        # what it writes: position / velocity / effort
    def _resolve_joints(self, robot):                         # which DOFs it drives
        return robot.articulation.find_joints([".*_elbow_joint"])[0]
    @property
    def action_dim(self): return len(self.joint_ids)
    def compute(self, action):                                # PURE: action -> joint targets
        return action                                         # self.robot / self.limits available

env.robot.set_controller(ElbowWiggle())                       # live; bypasses control_modes

compute is pure math; the inherited apply writes its output through the sink the robot handed the controller at bind (matching command_type). For a fully custom path, override robot.apply_action instead. This is the seam for the agent's own controllers — the env owns the slot, the agent owns the policy.

Combine controllers. Two composable axes:

• Different joints → CompositeController (the action is split across groups; groups may even use different command_types — e.g. effort arms + position hands, each writing its own):

  from robobench.controllers import CompositeController, JointController, JointControllerCfg
  env.robot.set_controller(CompositeController([
      MyArmController(),                                                          # your arm controller
      JointController(JointControllerCfg((".*_hand.*",)), command_type="position"),   # hands, direct
  ]))
  

• Same joints → a residual wrapper (base.compute(action) + scale · correction), itself a controller, so it nests inside a composite leaf. (Planned; the correction net is agent-side.)

Tune the build (gains, placement, sim). It's all config — override on the EnvCfg, its robot_cfg, or per-build:

from robobench.robots import G1RobotCfg
EnvCfg(scene="ikea_table", robot="g1", control_mode="joint",
       robot_cfg=G1RobotCfg(arm_stiffness=1500.0, base_pos=(0.0, -0.6, 0.75)),   # softer arms, moved back
       sim_overrides={"dt": 1 / 200}).build(num_envs=16)

Snapshot & restore (debug / RL). Capture full state and jump back to it — replay a hard phase, or stand up a small RL loop from a saved snapshot rather than from the episode start:

s = env.get_states()        # {"scene": ..., "robot": ...}
# ... drive / train ...
env.set_states(s)           # restore to ANY saved state

---

Layout

robobench/
  core/      shared machinery — BaseScene · BaseRobot · BaseEnv · BaseVerifier,
             scene introspection (describe_stage), registries (SCENES · ROBOTS)
  robots/    reusable embodiments — where concrete control pipelines / gains / IK live
  suites/    the task families (one folder per flavor; see each suite's own docs)

A per-suite section (what each flavor contains, how to add one) will be added once the first suite is built.