acceptodds
Under review as a conference paper at ICLR 2027

Eden: One Task Definition from Simulation to Real Robots

10 views

Abstract

Simulation has become central to robot learning, yet a task is often reimplemented as it moves from training to data collection, evaluation, and real-world deployment. In particular, deploying a policy on a physical robot typically requires reconstructing its observation and action pipelines against a new hardware interface, creating duplicated code and opportunities for subtle inconsistencies. We present Eden, a robot-learning framework in which a task is defined once and executed across simulation and hardware. Eden represents each task as a typed, serializable configuration of reusable terms operating over name-resolved entities. This separation of task semantics from the underlying execution substrate allows a simulated robot to be replaced by a hardware-backed entity while preserving the observation, action, and command code used during training. The same task definition also supports data collection and evaluation under alternative physics without reimplementation. We test whether this abstraction yields measurable benefits. In a controlled agentic benchmark across Eden, IsaacLab, and mjlab, Eden reduces the effort required by coding agents to construct novel tasks involving new scenes and component composition, despite substantially less prior exposure to Eden code. We show that policies trained in simulation transfer to hardware such as the Unitree G1 and LimX Oli without rewriting their observation or action pipelines. Separately, a vision-language-action policy fine-tuned on only 100 simulated demonstrations collected in Eden succeeds in 27/30 real-world pick-and-place trials. Together, these results show that training, data collection, evaluation, and deployment can be different executions of a single robot-learning task definition rather than separate implementations.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Robot Learning Framework, Simulation, Deployment

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_A6i6OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This submission introduces Eden, a simulation framework for robot learning that a task can be just defined once and then executed across simulation backends and on hardware. The core idea is to represent each task as serializable configuration of reusable terms. Experiments show that coding agents derive working policies faster with Eden. A learned locomotion task (quadruped backflip) is demonstrated for sim2real transfer. And data collected in Eden can be used to train manipulation policies for pick-and-place tasks.

Critical strengths
  • Reducing task reimplementation across training, evaluation, real-robot deployment, etc., is important and promising.
  • The proposed framework also unifies a few segmented simulation backends.
  • Experiments show that it's coding agent friendly.
Critical weaknesses
  • A bit unclear how does the submission fits into ICLR. The submission reads mostly like a software/programming advancement.
  • It's unclear how does Eden work with more diverse and complex tasks.
  • Eden is only verified on locomotion task and a simple pick-and-place task for sim2real transfer. While for locomotion tasks, sim2real transfer is a solved problem, it's unclear how does Eden can further advance manipulation tasks.
Questions for authors

How does Eden handle sim2real gaps?

1 comment

Thank you for the review. We address each of your concerns below.

Hardware results. Two experiments ran on hardware:

  • Unitree G1 whole-body tracking (Table 4, App. I.1). Five BeyondMimic policies trained in Eden and deployed with no observation, action or command code rewritten passed 47 of 50 trials. The three failures had external causes, a disconnected wired link and tension in the gantry tether.
  • UR10e manipulation (Table 30, App. I.2). GR00T N1.7, fine-tuned only on 100 demonstrations collected in Eden in a Gaussian-splat reconstruction of the workcell, succeeded in 27/30 real trials. The same collection in IsaacLab gave 23/30, a background that was not reconstructed gave 0/30, and the base checkpoint gave 0/30.

Manipulation. The release supports manipulation in data collection, evaluation and deployment. Teleoperation devices (GELLO, Meta Quest, PICO, Wuji glove) record HDF5 demonstrations that convert to LeRobot datasets. Batched Gaussian-splat scenes render a reconstructed workcell per environment for visual policies. VLA clients, among them π0.5, GR00T and Octo, run in Eden tasks for evaluation. Deployment backends cover the Franka Panda and FR3, the XHand and the Wuji Hand, and an arm with a hand deploys as one robot. The README (in the anonymized repository, https://anonymous.4open.science/r/eden-anon-1A3B/) shows a pen-spinning policy run on a real Wuji Hand 2 with eden deploy. The paper reports manipulation hardware trials for the UR10e only, where the VLA's own server drives the arm (§5).

ICLR area. We submitted Eden to the area "infrastructure, software libraries, hardware, etc.", and ICLR has published library papers such as TorchRL (ICLR 2024). Robot-learning methods are trained and evaluated on task definitions, and Eden is infrastructure for writing and deploying them. The paper measures two costs that a learning researcher pays: writing a new task (§4.1), and running a trained policy on a robot, which in Eden needs no second implementation of its processing (§4.2).

More diverse and complex tasks. The release has 66 tasks, among them multi-clip and hand-object motion tracking, humanoid skateboarding, extreme parkour, dexterous lifting, in-hand reorientation, bimanual piano, cloth folding, cable routing and wiping with a soft sponge, plus the robosuite, LIBERO, SIMPLER and PolaRiS suites. App. H gives full specifications for twelve. Eden exposes rigid, MPM, SPH, PBD, FEM, IPC, and Mochi physics (Table 5).

Sim-to-real gap. Eden handles the gap with tools in the same configuration that defines the task:

  • In training, actuator terms model delay, friction, backlash, deadband and motor strength. Randomization events vary gains, mass, center of mass, friction and pushes, and observation terms take delay and noise.
  • System identification drives excitation signals (chirp, PRBS) on the robot through the deployment backend, records the response, and fits joint damping, armature, friction and gains with batched rollouts (App. M).
  • A quantity that the robot cannot measure is removed from the task or estimated. A contact-aided Kalman filter over IMU and leg odometry feeds base velocity to the same observation term. An action channel that the robot has no port for must be listed, or construction fails.
  • Before hardware, a MuJoCo backend runs the identical deployment loop against a MuJoCo model of the robot. Every deployment run can record the commanded and measured state at each step.

Entity replacement removes one software cause of the gap, deployed observation and action code that differs from the code used in training. The G1 trials ran with all training-time randomization disabled (Table 4).

Reviewer_jXTSOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3(+1)
Soundness
2
Read review
Paper summary

This paper introduces a software/library that aims to simplify robot learning task definition and implementation by allowing tasks to be defined once and reused across different platforms and hardware. The authors describe its abstractions and components, design a coding-agent benchmark to verify the approach’s effectiveness, and provide some evidence of its effectiveness.

This is primarily a software/library contribution. While the motivation is sound, the experimental settings and results are somewhat limited and do not provide a sufficiently strong signal. I recommend rejection.

Critical strengths
  • The motivation is clear and focuses on a major pain point in robot learning: tasks defined in software often need to be reimplemented across stages. The paper proposes the Eden framework to address this issue, and its architecture and details are well grounded in this motivation.
  • The reverse-style coding agent benchmark evaluation is innovative. By fixing the task, agent, and other settings while varying the framework, the authors obtain interesting signals about how well the frameworks work and how they differ under the same settings, and provide some justification for the results.
Critical weaknesses
  • For a paper focused solely on a software/framework contribution, it is important to provide the repo/software with demos to help readers understand and evaluate the work. The main paper primarily explains the concepts and key components. Although the appendix provides substantially more detail, it is too long and does not help reviewers develop a clear understanding of the approach’s practical effectiveness.
  • The experimental settings have several limitations, including the small number of task types (5) and frameworks (3) in the coding agent benchmark comparison (Table 2), as well as limited robot evaluations. For a software contribution, the evaluation should be more comprehensive.
Questions for authors

Could you share an anonymous link to the repo? Reviewing the code would be very helpful for better understanding the work and assessing its quality.

2 comments

Thanks authors to provide the anonymized repository. After reviewing the code and the demo, I decided to raise my score to 3.

Thank you for the review and for asking for the code. We agree that Eden is primarily a software and library contribution, and the code is its main artifact. We address each of your concerns below.

Anonymous repository. https://anonymous.4open.science/r/eden-anon-1A3B/ (keep the trailing slash, or the README images do not load). It holds the current release: 210,010 non-comment lines of Python in 947 modules, 5,694 test functions in 502 files, 118 documentation pages including 41 guides, and 193 example scripts. The README gallery has the demos, including three policies run with the same eden deploy command in MuJoCo and on the real G1, LimX Oli and Wuji Hand 2.

These commands give a short tour:

  • eden list prints every registered task and its variant flags.
  • eden terms --grep friction prints a term's parameters, types and defaults.
  • eden smoke --task reacher --cpu builds a task and steps it without a GPU.
  • eden train --task <task>, then eden deploy --task <task> --checkpoint <model.pt> --mujoco, runs the trained policy through the hardware deployment loop against MuJoCo.

The paper's parts are in these files:

  • Task configuration and validation (§3.1): eden/tasks/, grouped by task family. eden/resources/term_catalog.md lists all 246 registered terms, and docs/guides/error-messages.md specifies what a configuration error must say.
  • Entity replacement and deployment (§3.3, App. D): DeploymentBase in eden/extensions/deployment/base.py, the entity that reports measured state in eden/extensions/deployment/utils/state.py, one backend file per robot, and composite.py for an arm with a hand.
  • Sim-to-real tools: actuator models in eden/managers/modifiers/actions/actuators.py, randomization events in eden/managers/terms/events/domain_rand.py, and system identification in eden/extensions/sysid/.
  • Task specifications (App. H): docs/tasks/, with runnable projects in examples/.

The release is newer than the evaluated commit, so some counts are higher than in Table 5 (246 registered terms against 227).

Appendix guide. We agree that the appendix is hard to navigate. The revision opens it with a one-page guide that maps each main-text claim to the appendix section and table that support it.

Evaluation scope. We evaluate Eden as a library: by the workloads it supports and by what it costs to use. The release has 66 tasks across locomotion, parkour, motion tracking, dexterous, bimanual and deformable manipulation, and piano, plus ports of robosuite, LIBERO, SIMPLER and PolaRiS; App. H specifies twelve in full. To measure cost, the benchmark has more than Table 2's five tasks:

  • Table 3: the Go1 backflip under four coding models, where Eden passes 13/18 rollouts against 10/18 for IsaacLab and for mjlab.
  • Table 33: eight tasks with Claude Opus 5.5, with time split into agent-side and compute-side.
  • Tables 34 and 35: a 36-task suite of edits that covers every manager, checked by a probe that is the same in all three frameworks.

We compare against IsaacLab and mjlab because they also compose tasks from manager terms (§2), so one task description can be implemented and checked the same way in all three.

On hardware, five whole-body tracking policies passed 47 of 50 trials on the Unitree G1 (Table 4). A UR10e VLA fine-tuned only on demonstrations collected in Eden succeeded in 27/30 real trials. The same collection in IsaacLab on the same Gaussian-splat scene gave 23/30, and the base checkpoint 0/30 (Table 30).

Reviewer_HXm1OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper addresses inconsistencies between task implementations used for training and deployment in robot learning. It presents Eden, a framework that represents tasks through typed, serializable configurations, reusable observation/action/command terms, and named entities. Replacing the entity backend allows task-processing code to be reused across simulation and hardware. The authors demonstrate the framework on simulation and hardware workloads and report improved coding-agent implementation efficiency on some task-authoring workloads, suggesting practical benefits of the design.

Critical strengths
  • The framework offers a coherent workflow for implementing robot-learning tasks and deploying policies. Reusing observation and action processing can reduce duplicated implementation work, and the hardware demonstrations provide evidence of its practical utility.
  • The coding-agent comparison is a useful attempt to quantify framework usability through task completion and implementation effort. It provides empirical evidence beyond a list of supported features, including improvements on selected workloads and cases without a clear advantage.
Critical weaknesses
  • The research contribution beyond software abstraction and integration is not sufficiently established. Despite the emphasis on defining a task once, the framework appears primarily to reorganize task components behind shared interfaces. Relevant ideas already exist in manager-based task composition in IsaacLab and simulation/hardware abstraction in RoboHive [1]. The paper does not clearly establish what additional capability or generalizable insight its design provides beyond these approaches. Its benefits may largely reflect implementation organization and configuration conventions. I therefore find the case for a useful open-source engineering contribution stronger than the case for a distinct research contribution in the current submission.

  • Some experimental descriptions and reporting conventions require clarification. Appendix J.1 excludes tasks requiring unsupported physics, and Table 31 specifies separation of an MPM continuum slab, yet Table 33 reports a successful deformable-cutting run for “IsaacLab 2.1.0 (no MPM).” The actual task and success criterion for this run are unclear. In addition, Table 2 reports a mean time to a working policy for mjlab bin picking despite one failed rollout, without explaining how that failure enters the mean. These ambiguities limit confidence in the interpretation of the benchmark results and reported efficiency gains.

Questions for authors

These are clarification requests about the submitted work.

  • Relative to RoboHive, IsaacLab, and related frameworks, what specific capability or generalizable insight does Eden introduce beyond reorganizing components behind a shared interface? Which part of the submitted evidence demonstrates this incremental contribution?

  • Which backend, material model, and checker produced the successful “IsaacLab 2.1.0 (no MPM)” cutting result in Table 33? Did this run satisfy the same continuum-separation condition as the other cutting experiments?

  • For Table 2’s mjlab bin-picking result (4/5 successes), how is the failed rollout handled in the reported mean time to a working policy? Please clarify whether this is a successful-run mean or a budget-censored measure, and provide the per-run values or dispersion needed to interpret the reported speedup.

3 comments

We thank the reviewer for the time and effort devoted to evaluating our work and for the constructive feedback. We address each of your concerns below.

We submitted Eden to the area "infrastructure, software libraries, hardware, etc." because the library is the contribution. The anonymized repository, https://anonymous.4open.science/r/eden-anon-1A3B/, holds the current release. Q1 asks what it adds to IsaacLab and RoboHive, and we answer with files in the release.

Q1. What Eden adds to IsaacLab and RoboHive. Eden adopts IsaacLab's manager-based design (§2, Table 1). RoboHive switches one environment between simulator and hardware through its robot interface, and the revision cites it in §2. Eden puts the hardware boundary at the entity, below the managers. Terms read state and send commands only through an entity, so replacing the simulated entity with one that reports measured state moves the whole task onto the robot. Four capabilities follow, and each can be checked in the release:

  1. The training pipeline runs on the robot. The observation, action and command managers that trained the policy run at deployment, including scaling, clipping and PD targets (§3.3, App. D). Five BeyondMimic policies ran on a 29-DoF G1 with none of that code rewritten, and passed 47 of 50 trials (Table 4). IsaacLab and MuJoCo Playground deploy through robot-specific scripts that reimplement this processing (§2).
  2. A new robot needs only a small backend. DeploymentBase (2,126 non-comment lines) contains the entity swap, the operator state machine, the start-up and gain ramps, and recording. The backend for a robot implements its wire protocol: 187 lines for the G1, and 86 for the Go2 on a 156-line DDS transport that the two share.
  3. Backends combine. An arm with a hand, such as the Franka Panda with the XHand, deploys as one robot through the two parts' backends (composite.py). MuJoCo sim-to-sim is one more backend, and it runs the same loop (eden deploy --mujoco).
  4. Other parts of the library use the same boundary. System identification drives the robot through the deployment backend and fits the simulated entity's parameters (eden/extensions/sysid/). The 21 policies in the zoo were reimplemented in Eden, and they run through Eden's managers and can be deployed with the same deployment backend.

The paper reports two further results. In the 36-task suite, two tasks set a parameter through a misspelled field. Eden rejects both at import, with an error that names the field and the valid alternatives, while IsaacLab and mjlab accept both and the fault shows only in the result (App. J.3). In the coding-agent benchmark, with agent, task description and checker fixed, Eden passes the most backflip rollouts (13/18 against 10/18 and 10/18; Table 3), is fastest on door opening and deformable cutting (Table 2), and passes bin picking 5/5 with the shortest median time (Q3).

For a generalizable insight beyond implementation organization, the number of copies of a policy's processing depends on where the hardware boundary sits. A deployment script sits above the observation, action and command code, so that code is written a second time for the robot and the two copies can drift. When every term reads and commands the robot through one replaceable object, the boundary sits below that code, and one copy runs in simulation and on hardware. The rule holds only if the framework enforces it, because a single term that kept a handle to the simulator would read simulated state on the robot and raise no error. Eden enforces it when it constructs a deployment. It finds every reference to the simulated robot held by an observation term, an action term or their modifiers, points each one at the hardware robot, and raises an error if a reference is held in a form it cannot repoint (DeploymentBase in eden/extensions/deployment/base.py). An action term that the robot has no channel for also fails construction, unless the real robot produces its effect itself. The rule and the check need only manager-based terms that reach the robot through a scene entity, which IsaacLab and mjlab also use.

Q2. The "IsaacLab 2.1.0 (no MPM)" cutting cell of Table 33. No, the run did not meet the continuum condition. IsaacLab 2.1.0 has no MPM material, and the agent modeled the dough as PhysX position-based-dynamics (PBD) particles. The checker tests particle positions only, and the run passed it: 6,400 particles exported, a 25.2 mm gap (threshold 12 mm), 47% of the dough in the smaller piece (threshold 35%), and the blade at the bottom of the 32 mm slab. The revision labels the cell "IsaacLab 2.1.0 (PBD particles)" and says so in App. J.2 and the caption. No claim in the paper rests on this cell. Table 2's IsaacLab cutting cell is a different run, on IsaacLab's experimental Newton MPM backend (App. J.1).

Q3. mjlab bin picking in Table 2. We re-ran bin picking with Claude Opus 5, five rollouts per framework, with the same budget, checker and GPU type. A failed rollout counts at the 180 min budget. Total wall-clock per rollout, in minutes:

  • Eden, 5/5 successes: 29.8, 28.7, 36.9, 14.3, 18.8 (median 28.7, IQR 18.8–29.8)
  • mjlab, 5/5 successes: 55.2, 42.2, 45.4, 54.9, 57.9 (median 54.9, IQR 45.4–55.2)
  • IsaacLab, 2/5 successes: 180, 180, 99.6, 105.4, 180 (median 180, IQR 105.4–180)

Eden passes all five rollouts. Its median of 28.7 min is close to its Table 2 mean of 29.4 min, and about half of mjlab's 54.9 min. We could not recover the per-rollout records of Table 2's Claude Opus 5 cells, so we cannot say whether the failed mjlab rollout entered that mean at the budget. The revision keeps Table 2's numbers, says this in §5, and reports every per-run value in App. J.5 (Table 36).

Comments on the paper

2 comments

Dear Reviewers,

Please read the authors’ response and let us know whether it addresses your concerns. If any concerns remain, please briefly indicate which ones.

Thank you for your time and for your thoughtful reviews.

Best,

AC

AuthorsOpenReview ↗

General response

We thank the reviewers. All three reviews read Eden as a software contribution: HXm1 finds "the case for a useful open-source engineering contribution stronger", jXTS calls it "primarily a software/library contribution", and A6i6 says it "reads mostly like a software/programming advancement". We agree, and we submitted Eden to the ICLR 2027 area "infrastructure, software libraries, hardware, etc." for that reason. We ask that it be judged as a library, by what its code does. The anonymized repository, https://anonymous.4open.science/r/eden-anon-1A3B/, holds the current release. This comment lists what a reviewer can check there, and the replies to each reviewer answer the other points.

The task configuration. A task is one typed configuration composed from registered terms. The same object is the input to eden train, eden inference, eden deploy --mujoco (sim-to-sim), eden deploy (hardware) and eden export (ONNX or TorchScript with a policy_spec.json).

What the release contains.

  1. A term's class is its own configuration schema. A misspelled field or an unknown term, entity, link or joint name raises an error when the task is built, and the error message names the valid options and the fix (docs/guides/error-messages.md).
  2. One deployment loop runs every robot. DeploymentBase (eden/extensions/deployment/base.py, 2,126 non-comment lines) swaps the simulated robot for one that reports measured state. It also contains the operator state machine, the start-up and gain ramps, a check for joints whose sensor readings stop changing, and streamed recording. Supporting a new robot means writing its wire protocol, and the Unitree G1 backend that does this is 187 lines. Backends ship for the Unitree G1, Go1 and Go2, LimX Oli, Franka Panda and FR3, RoboTera XHand and Wuji Hand, and any robot runs against MuJoCo with --mujoco. An arm with a hand deploys as one robot through the two parts' backends (composite.py).
  3. The sim-to-real models are terms in the same configuration: actuator models for delay, friction, backlash, deadband and motor strength; randomization events for gains, mass, center of mass, friction and pushes; and observation delay and noise. System identification (eden/extensions/sysid/) drives excitation signals on the robot through the deployment backend, records the response, and fits simulation parameters with batched rollouts.
  4. The release has 66 tasks, 47 robots, 11 composite rigs, 950+ objects and 246 registered terms (eden/resources/term_catalog.md). Training runs on rsl_rl, rl_games, skrl or Stable-Baselines3, or through gym.make_vec("Eden/<task>"), with multi-GPU DDP. 21 published controllers and VLA clients run through the same managers, among them SONIC, BeyondMimic, π0.5 and GR00T. The release also includes teleoperation, motion retargeting, and recording to HDF5 and LeRobot.
  5. The code is 210,010 non-comment lines of Python in 947 modules, with 5,694 test functions in 502 files, 432 of them for deployment. CI installs the package, lints it, resolves every registered task, and builds the documentation in strict mode. The release has 118 documentation pages, 193 example scripts, and an AGENTS.md for coding agents.

What the paper measures. Five whole-body tracking policies trained in Eden ran on a Unitree G1 with no observation, action or command code rewritten, and passed 47 of 50 trials (Table 4). A VLA fine-tuned only on demonstrations collected in Eden succeeded in 27/30 real UR10e trials, against 0/30 for the base model (Table 30). In the coding-agent benchmark, the agent, task description and checker are fixed and only the framework varies. Eden passes the most backflip rollouts there (13/18, against 10/18 for IsaacLab and for mjlab; Table 3). Eden also passes bin picking 5/5 with the shortest median time (28.7 min, against 54.9 for mjlab; IsaacLab passes 2/5; App. J.5). The README shows three policies run with the same eden deploy command on the real G1, LimX Oli and Wuji Hand 2; the paper reports trial counts only for the G1.

Changes in the revised PDF.

  1. §2 cites RoboHive and states what Eden adds to it (reply to HXm1).
  2. Table 33's IsaacLab 2.1.0 cutting cell is relabeled "PBD particles", and App. J.2 explains why (reply to HXm1).
  3. Table 2's "pass@5" column is renamed "Successes / 5", the count of the five rollouts that passed.
  4. §3.3 and App. D describe the released backend interface: connect, close, read_state and send_payload, with the start-up ramp shared in DeploymentBase.
  5. App. J.5 reports bin picking with every per-rollout time (reply to HXm1, Q3).
  6. A one-page guide opens the appendix and maps each main-text claim to its section and table (reply to jXTS).

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.