acceptodds
Under review as a conference paper at ICLR 2027

Language to Design (L2D): Towards Self Evolving Robots

13 views

Abstract

Designing a robot requires expertise in both complex mechanics and control. This process typically relies on slow cycles of estimation, prototyping, and testing to find where design and behavior align. This raises a fundamental question: can robot design be made as simple as describing what we want a robot to do? We present Language to Design (L2D), a co-design framework that turns a prompt and an existing robot into an optimized body, a motion that performs the task, and manufacturable parts, without tuning or training per task or per robot. The framework supports 1) language proposals grounded in measured physics, where language reflection decides what to change and physics measured in simulation decides how much, 2) a continuous design space, spanning link kinematics, motors, added joints, and continuous morphology designs for contact points such as feet and fingers, and 3) real-world fabrication, where prompt with stress-based topology optimization turns added parts into light, manufacturable components can be deployed zero shot on hardware. We demonstrate L2D by co-designing quadrupeds, arms, grippers, dexterous hands, and humanoids across eleven tasks on nine different robots, and deploy a printed design zero shot on a real quadruped for a climbing task. Task videos are available on our anonymous website.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Co-design, robotics, design generation

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_Sv8rOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a framework that jointly searches over robot morphology and motion given a natural-language task, the MJCF file of an initial robot, and a task scene. The system automatically constructs the design parameter space; a language model generates rewards, design constraints, and candidate designs, and proposes directions for modification based on failure feedback. The framework builds a regression surrogate using 33 physical descriptors and maps directions in the descriptor space to design parameter updates, then uses CEM-MPC to search for motions. The main contribution of this work is the system-level integration of a cross-robot design representation with language, physical feedback, and control search. The authors report five main tasks covering five robot families, additional tasks, and cross-task transfer, involving eleven tasks and nine robots in total. They also report a real-world climbing deployment on a Go2 with printed add-on parts.

Critical strengths
  1. The combination of language-based proposals and physics-based updates has a clear technical motivation and receives preliminary support from ablations. The design surrogate is built on interpretable physical quantities, and the finite-difference Jacobian maps the desired changes back to parameter space, enabling directed search without training a control policy or relying on differentiable dynamics.
  2. The integration of a cross-robot design representation with the manufacturing pipeline has substantial engineering value. The system can automatically parse MJCF and handle parameters, contact geometry, and structural operations across different robot families within a single pipeline.
Critical weaknesses
  1. The main comparisons are confounded by differences in budgets and evaluation environments and are not yet sufficient to establish the optimization advantage of the method itself. The language-driven comparisons fix only the language-model expenditure at $3.33 per seed, without also matching the number of design evaluations or the total simulation budget. Better performance at the same language-model expenditure is a valid system-level observation, but it does not, by itself, establish that physical feedback is more effective or that the total computational cost is lower.
  2. The evidence for broad automation, generalization, and hardware deployment is less substantial than the paper's central claims suggest. The method is described as requiring no per-task or per-robot tuning and using language to generate designs and motions. However, the experimental details indicate that several main tasks use fixed reward files. For bin picking and free throws, the initial motions generated by the language model failed to obtain any score, and the runs were restarted with task-specific scripted motions after approximately four hours. This does not negate the value of avoiding policy training, but it indicates that the sources of the rewards and initial motions, human intervention, and the actual scope of applicability must be disclosed.
Questions for authors
  1. Under the same MuJoCo version, task scene, frozen evaluation criteria, and initial states, does L2D retain its advantage over the other methods when both the number of actual design evaluations and the simulation budget for control search are matched?
  2. For each main task, are the final rewards, evaluation criteria, control configurations, initial motions, and structural operations generated by the system, supplied by existing task assets, or written or modified by humans? Please use this information to precisely define what is meant by "no tuning" and "zero-shot".
  3. How many real-world climbing trials were conducted with the Go2, how many succeeded, and how did the original robot perform under the same test conditions? Please report the deployed control method, any human adjustments, and the mass, maximum stress, displacement, and task success rate before and after optimization of the printed parts. Was a dynamics evaluation performed again using the optimized geometry?
1 comment
AuthorsOpenReview ↗

Thank you and Revisions

We thank the reviewer for recognizing the technical motivation and the engineering value of the cross-robot design representation.

**Q0:**Does L2D retain its advantage when both the number of design evaluations and the simulation budget are matched?

A0: We agree that matching language spending is a system-level comparison. We reran every method with both the number of design evaluations (100 per seed) and the simulation and wall-clock budgets matched, on MuJoCo 3.11, with the same scenes, frozen judges, and control warm start. L2D keeps the best mean on the hurdle (20.2 against 16.1), the toss (43.8 m against 30.0 m) and bin pick (16.18 against 16.02), ties the free-throw ceiling, and sits on the pen-spin plateau with VLMgineer; its normalized gain is 1.00 against 0.76 for the next method. L2D therefore retains its advantage when both design evaluations and simulation budget are matched. Every final design, for L2D and every baseline, is also re-flown under a longer control search than the search episode and judged on that flight, so designs that overfit the short-horizon reward and fail as the episode runs on are not credited.

Q1: For each main task, are the final rewards ... or written or modified by humans? Please define "no tuning" and "zero-shot".

A1: In the matched rerun reported above, each component comes from the following source:

  • Reward: Each task ships one reward file as a task asset, which VLMgineer, BO and CMA-ES optimize unchanged. RoboMoRe and Eureka+Random Design rewrite their rewards with the language model, as in their original methods. L2D's reward is written by the language model and rewritten every two rounds (same as RoboMoRe); the task's reward file is only a candidate at round 0, so L2D's final reward is always language-written. Every candidate reward is ranked by the frozen judge, which no method can rewrite.
  • Evaluation criteria (judge): Written by the language model from the prompt, read and signed off by the user, then hashed and frozen before any method runs. Clauses that close loopholes found while building the suite were added by hand (App. "Reward Hacking"). The same frozen judge scores every method.
  • Controller settings: One set of CEM settings per task (horizon, iterations, population), fixed before any method runs and shared by every method. This is the one per-task setting chosen by hand; otherwise the defaults are used.
  • Initial motions: Every method gets the same control warm start: each design's control search starts from the best motion found so far, transferred onto the new body.
  • Structural operations and design space: Read from the MJCF by the parser and fenced by the prompt's scope, with no per-task code. Every method searches the same design space.

"No tuning" means that none of these is set per task or per robot by hand, except things we list explicitly: the user defined controller settings and the hand-added judge clauses. "Zero shot" means that the printed part and the controller solved in simulation run on the real robot with no on-robot tuning or training.

Human involvement and the prompt are now specified in the Method. The user writes a prompt that names one completion event observable in one episode. It may also say how the task must not be done and set a design scope. The user then signs off the judge and the design space. Constraints the prompt states are hard, what it leaves open is a soft default the user signs off (Sec. 2.2). The limitations (Sec. 5) state what this cannot guarantee a loophole in a signed-off judge, a pass the user did not intend, a badly scoped design space, or tasks without a graded signal.

Q2: How many real-world trials were conducted, how many succeeded, and how did the original robot perform?

A2: We replaced the single real world paragraph with two quantified comparisons against the stock robot (Sec. 4.1, Table 1):

  • Go2 soccer kick: Printed blade and stock foot, 6 kicks each: median apex rise 0.95 m against 0.16 m, flight 0.90 s against 0.37 s, launch angle about 60 against 17 degrees.
  • YAM candy transfer: Printed scoop against the stock gripper, 6 runs each: 96.2 candies per run (92-103) against 1.5 (0-3); all 12 runs complete. This arm task was added to show that the same loop and deployment path generalize beyond legged robots.

Deployed control: The final design's motion is re-solved with DIAL-MPC under the robot's real motor and joint-speed limits and exported as a tape of joint targets tracked by the stock PD controllers.

Printed part before and after FEA co-design: 549 to 104 cm^3 (680 to 130 g), peak von Mises stress 15.6 to 14.4 MPa, below the 20 MPa limit, largest displacement 1.4 to 4.4 mm.

The optimized geometry is re-evaluated in dynamics. The blade is re-solved under the real motor limits and scored over 400 randomized worlds (2.78 m on average, against 1.90 m and 65% for the stock Go2).

Please let us know if additional detail would help.

Reviewer_g3S8OpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

L2D takes a text prompt and a robot's MJCF and returns a modified body, a motion and printable parts. An LLM writes a reward for a training-free MPC planner, restricts the design space and proposes edits. The design space is built automatically from the MJCF and covers numeric parameters, generated contact geometry and structural edits such as joint splices. Physics-guided edits come from a regression model over measured physical quantities, mapped back to the design parameters. A frozen pass/fail judge, separate from the reward, ranks the designs. The evaluation compares L2D with three LLM co-design baselines at matched LLM cost and with random search, BO and CMA-ES, and adds ablations, held-out tasks and a Go2 box climb on hardware.

Critical strengths
  1. The design space is the most useful part for me. It's built straight from the MJCF, handles topology changes and generated contact geometry, and round-trips exactly on 86 of 103 unseen MuJoCo Menagerie models. Most co-design work uses small, benchmark-specific spaces, so this would be useful to others even without the LLM part.

  2. The ablations are honest about what matters. Replacing the physics edits with random mutations clearly hurts the toss (best throw 14.2 to 8.5 m), letting the LLM propose every edit trades peak performance for pass rate, and the control warm start turns out to be the biggest single factor. I also liked that failures are reported, including CMA-ES coming out ahead.

Critical weaknesses
  1. The comparison matches LLM spending, but not search effort or setup, and three seeds aren't enough to separate the methods. For the same budget, L2D proposes roughly ten times as many designs as the baselines (Table 2), only L2D gets the design screens, and the black-box baselines start from a cold controller. These are fair parts of the method, but they make it hard to credit the proposer. On the toss, the L2D and VLMgineer intervals overlap. Table 5 also averages over different task sets for different methods, and with one consistent rule CMA-ES comes out ahead of L2D.

  2. The main experiments test less of the pipeline than the abstract suggests. Four of the five main tasks use a fixed reward file shared by all methods (App. A.4), so the LLM-written reward is only really tested on pen spin and the held-out tasks. On two tasks the LLM-written motion failed and the runs were restarted from scripted motions. The held-out results are mixed, and on the rocky slope the final designs do worse than the stock robot. The "zero shot on hardware" claim rests on one paragraph and a video, with no trial count or success rate.

Questions for authors
  1. What does L2D reach with the same number of designs as the baselines, and how do the baselines do with the same screens and warm start?
  2. Did the language-driven baselines get the same control warm start? Without it, L2D's toss roughly halves (Table 3).
  3. For the hardware: how many trials, what success rate, and how does the stock Go2 do?
  4. How does L2D do on the main tasks with its own LLM-written reward and starting motion?
  5. Pen spin is described inconsistently: Sec. 4 says no method completes the turn, Fig. 9 says L2D passed 1 of 4 tries, and Table 2 gives a pass rate of 0. Which is right?
  6. Algorithm 1 and App. A.4 give different numbers of selection starts. Which setting produced the reported numbers?

Other suggestions:

  • A few things look unfinished: a "VERIFY" note in the GPT-6 Astra reference, a "(running)" entry in Table 4, and "(Opus)" in the Fig. 11 legend.
  • Fig. 1 and Table 3 give different toss distances for the stock robot (6.0 vs 4.5 m).
  • Lehman et al. (2022) on evolution through large models and LLAMBO (Liu et al., ICLR 2024) seem relevant for the related work.
1 comment
AuthorsOpenReview ↗

Thank you and Revisions

We thank the reviewer for the detailed review and for finding the design space useful on its own.

**Q0: The comparison matches LLM spending but not search effort or setup... **

A0: We reran every method under one rule. 100 simulated designs per seed for every method, equal simulation and wall-clock budgets, the same control warm start for every method, the same simulator, frozen judge and six held-out starts, all methods on the same five tasks (so the averaged gain is over one task set), five seeds per baseline and eight for L2D, with 95% intervals:

Final design on held-out startsL2DRoboMoReVLMgineerEureka+RandomBOCMA-ES
Hurdle20.2 [19.0, 21.3]16.115.714.012.713.0
Toss (m)43.8 [30.6, 55.5]17.823.118.030.029.7
Bin pick16.1815.6615.8816.0016.0216.02
Free throw11.010.311.04.88.28.3
Pen spin9.93.910.08.06.78.8
Normalized gain1.000.510.760.490.590.65

Under this rule CMA-ES is no longer ahead. L2D's mean is above CMA-ES's on all five tasks. On the toss, L2D's interval lies above every baseline's mean, but its seeds spread from 13.3 to 62.7 m, so we describe the margin as a point estimate. All methods receive 100 simulated designs. Every final design, for L2D and every baseline, is also re-flown under a longer control search than the search episode and judged on that flight, so designs that overfit the short-horizon reward and fail as the episode runs on are not credited.

To isolate the physics edit itself, we also kept the loop fixed and swapped only the rule that turns the learned model into a design edit, on the toss:

Update rule (toss)Final distance (m)
Jacobian step on 33 physical quantities (L2D)55.7 [51.8, 59.0]
Screened random steps45.8
Parameter-space surrogate (same ridge ensemble on the raw design vector)33.8
One-knob coordinate steps33.8

**Q1: Did the language-driven baselines get the same control warm start? **

A1: In the runs reported in the results above, all methods received an equal warm start.

Q2: How does L2D do on the main tasks with its own LLM-written reward and starting motion?

A2: In the matched rerun, L2D searches under its own language-written reward on all five tasks. Every candidate reward is ranked by the frozen judge. Its results above are therefore with its own reward. In the language-budget comparison, the hurdle, toss, bin pick and free throw used a fixed reward shared by all methods. The Experimental Protocol appendix now states this for every comparison.

On the additional tasks, the final loop now improves on the stock robot on every task, means over three seeds on six held-out starts (Sec. 4). For example, the rocky slope 10.22 against 6.23, curling 4 of 18 starts in the house against 1, USB insertion 18 of 18 against 13, and box climb 11 of 18 against none. The earlier rocky-slope run that scored below stock was replaced by a longer control horizon evaluation and rerun. The Method now specifies the human role. The user writes the prompt and signs off the judge and design space, and writes no reward code, knob ranges or planner settings.

Q3: For the hardware: how many trials, what success rate, and how does the stock Go2 do?

A3: The paragraph is replaced by two quantified hardware comparisons, each against the stock robot under the same protocol (Sec. 4.1, Table 1).

  • Go2 soccer kick: printed blade 6 kicks, stock foot 7 kicks, same kick tape, gains and ball placement. The blade lofts the ball on each kick (median apex 0.95 m against 0.14 m, flight 0.90 s against 0.37 s).
  • YAM candy transfer: printed scoop against the stock gripper, 6 runs each, 96.2 candies per run against 1.5, all 12 runs complete. This arm task was added to show that the prompt-to-hardware path generalizes beyond legged robots.

Q4: Pen spin is described inconsistently. Which is right?

A4: L2D's final pen-spin design completes the full turn. A start passes when the hand turns the pen at least 0.98 of a full turn while holding it, never drops it, and holds it still at the end. L2D's final pen-spin design passes on 90% of held-out starts (mean 9.9 [8.7, 11.0] over eight seeds), against 88% for VLMgineer, 77% for CMA-ES, 70% for Eureka+Random Design and 33% for RoboMoRe. The earlier statements that no method completes the turn came from outdated runs and have been removed.

Q5: Which setting produced the reported numbers?

A5: Every reported number uses each design scored on 1 start, each round's three best on 4 starts, and the run's three best on 6 starts. The best of these is the final robot, re-judged on 6 held-out starts drawn from a separate stream.

We thank the reviewer again. The rerun under one rule substantially strengthened the comparison. Please let us know if any concern remains.

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

L2D co-designs robot morphology and control from an existing robot and language instructions. An LLM generates a planning reward and proposes geometric, mechanical, and structural edits. Candidates are evaluated using warm-started MPC and a separate task evaluator. A surrogate predicts performance from physical descriptors, while a finite-difference Jacobian translates promising descriptor changes into robot parameter updates. The search shifts from language proposals toward numerical updates as the surrogate improves.

Critical strengths

The implementation breadth is substantial. The framework supports multiple robot families and combines geometric, inertial, actuator, and contact-shape. The reconstruction tests on unseen robot models provide useful evidence that the representation extends beyond the main experimental examples.

The method provides useful combination of language priors and numerical feedback through physical-descriptor-to-design update. Learning performance in a compact physical-feature space and mapping improvements back to design parameters provides a practical way to guide the structural search.

Critical weaknesses
  1. The novelty of this paper needs more careful positioning. Language-guided co-design, morphology optimization and evolutionary tool–action search have substantial previous works. The strongest contribution appears to be the physical-descriptor/Jacobian mechanism and its integration into a broad system. In particular, separating the control reward from an outer evaluation objective already appears in RoboMoRe and Eureka.

  2. The specific optimization contribution is incompletely isolated. The ablations support the overall physics-edit mechanism but do not establish the necessity of their chosen descriptors or inverse-Jacobian update. Comparisons against direct parameter-space surrogates and simpler update rules would strengthen the methodological claim.

Questions for authors
  1. Can L2D and the strongest baselines be compared using the same simulator, judge, motion initialization, and total simulation or wall-clock budget?

  2. Which constraints ensure that changes to motor strength, mass, inertia, and geometry remain jointly realizable? What quantitative hardware results and repeated-trial comparisons are available?

3 comments
AuthorsOpenReview ↗

Thank you!

We thank the reviewer for recognizing the breadth of the implementation, the reconstruction tests on unseen robot models, and the value of combining language priors with numerical feedback through the physical-descriptor update.

Q0: The novelty of this paper needs more careful positioning. In particular, separating the control reward from an outer evaluation objective already appears in RoboMoRe and Eureka.

A0: We agree that the separation itself is not new, and the revised Related Work says so. What differs is how the outer objective is used. In Eureka, RoboMoRe, and Debate2Create, the objective is shown to the language model (Eureka feeds the task metric back through reward reflection, RoboMoRe states it in the morphology prompt with prior fitness values, and Debate2Create shows an archive ranked by it), so the search can still fit it. L2D's judge is written once, signed off by the user, hashed, hidden from the planner, and only ever made stricter.

Beyond the judge, we have re-centered the contributions on what we believe is new:

  1. A unified co-design loop across robot families: Runs unchanged across five robot families (15 tasks, 12 robots), with a design space read from any MJCF. Every prior language-driven method works in one family.
  2. Physics-grounded prompt-to-design translation: Language decides what to change, while a model built on 33 measured physical quantities with a finite-difference Jacobian decides by how much. In prior language-driven methods, the language model writes the numeric values itself.
  3. A training-free path from prompt to hardware: One sampling-based planner controls every candidate and the deployed design, and printed parts are optimized under the loads of their own motion.

Q1: Can L2D and the strongest baselines be compared using the same simulator, judge, motion initialization, and total simulation or wall-clock budget?

A1: Yes. Every method ran on MuJoCo 3.11 with the same frozen judge, six held-out starts, the same control warm start, the same planner settings, 100 simulated designs per seed, and equal simulation and wall-clock budgets.

Final design on held-out starts, mean [95% CI]

TaskL2DBest baseline
Hurdle20.2 [19.0, 21.3]RoboMoRe: 16.1
Toss (m)43.8 [30.6, 55.5]BO: 30.0
Bin pick16.18 [16.18, 16.19]BO / CMA-ES: 16.02
Free throw11.0 [11.0, 11.0]VLMgineer: 11.0
Pen spin9.9 [8.7, 11.0]VLMgineer: 10.0
Normalized gain over stock1.00VLMgineer: 0.76; CMA-ES: 0.65

Q2: Which constraints ensure that changes to motor strength, mass, inertia, and geometry remain jointly realizable? What quantitative hardware results and repeated-trial comparisons are available?

A2: Four rules keep a design consistent (Appendix: From Design to Hardware):

  1. Bounded, coupled design parameters: Every knob is a bounded change around stock (link length: 0.625–1.6×, mass: 0.5–2×, gear: 0.4–2.5×), and coupled fields move together. A longer link is heavier, with inertia scaled as s3s^3, and a generated part takes its mass and inertia from its volume.
  2. Physical feasibility checks: A design is simulated only if it builds, settles, and holds its home command without tipping or self-intersecting. A gripper must also open and close around the object.
  3. Hard prompt-scope constraints: The prompt's scope is a hard limit: an additive scope only adds printed material, and motors are re-rated only where the prompt allows.
  4. Structural constraints: A printed part must stay below a 20 MPa limit and a deflection limit under the loads of its own motion.

These rules do not guarantee that a re-rated motor or a lengthened link exists as a purchasable part; such designs are validated only in simulation.

The prompt's constraints on the body are hard, and everything it leaves open is a soft default that the user signs off on. Any default can be made hard by stating it in the prompt (Sec. 2.2).

Part 1/2

AuthorsOpenReview ↗

Generalization and Deployment, Part 2/2

Hardware results (Sec. 4.1, Table 1)

Each design is evaluated against the stock robot under the same protocol. Controllers are re-solved with DIAL-MPC under the real motor and joint-speed limits, with nothing tuned on hardware.

1. Go2 soccer kick : printed blade vs. stock foot

  • Trials: 6 kicks with the printed blade vs. 7 kicks with the stock foot.
  • Protocol: Same kick tape, gains, and ball placement.
  • Median apex rise: 0.95 m vs. 0.14 m.
  • Flight time: 0.90 s vs. 0.37 s.
  • Launch angle: approximately 60° vs. 17°.
  • Joint-speed guard: Stock swing trips the guard on 4/7 kicks vs. 1/6 with the blade.
  • Recovery: Robot stays upright after 5/6 kicks with the blade vs. 4/7 with the stock foot.

2. YAM candy transfer : printed scoop vs. stock parallel gripper

  • Trials: 6 runs per design.
  • Candies transferred per run: 96.2 (range: 92–103) vs. 1.5 (range: 0–3).
  • Spilled candies per run: Approximately 5 vs. 0.3.
  • Completion: All 12 runs complete.

This arm task was added to demonstrate that the same co-design loop and deployment path generalize beyond legged robots.

3. Printed calf : before vs. after FEA co-design

MetricBeforeAfter
Mass680 g130 g
Peak von Mises stress15.6 MPa14.4 MPa
Stress limit20 MPa20 MPa
Largest displacement1.4 mm4.4 mm

We thank the reviewer for these suggestions, which led to the matched comparison. Please let us know if further analysis would help.

Part 2/2

I thank the authors for their valuable additional experiments and analysis. As there's very little time remaining to thoroughly dig into the details, I would like to maintain my score and will be happy to see the paper accepted.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Comment and Overview of Changes

We thank all the reviewers for their careful reading and constructive feedback. We have revised the manuscript to address their concerns with key changes listed below.

Summary of revisions:

(All) Quantified hardware results. Two printed L2D designs are now deployed zero shot against the stock robot under the same protocol, with trial counts and per-trial measurements (Sec. 4.1, Table 1): a kicking blade on a Go2 (6 kicks against 7 with the stock foot; median apex 0.95 m against 0.14 m) and a printed scoop on a YAM arm (6 runs each; 96.2 candies per run against 1.5 for the stock gripper), 13 kicks and 12 arm runs in total. The YAM task was added to show that the same prompt-to-hardware path generalizes beyond legged robots to a robot arm. The box climb is now described as a simulation result only.

(All) Every method at the same design budget. We reran every method under one rule: the same simulator (MuJoCo 3.11), design space, frozen judge, six held-out starts, the same control warm start for every method, equal simulation and wall-clock budgets, and 100 simulated designs per seed on all five comparison tasks (five seeds per baseline). L2D has the best mean on the hurdle (20.2 against 16.1 for the next method), the toss (43.8 m against 30.0 m) and bin pick (16.18 against 16.02), reaches the free-throw ceiling of 11.0 as VLMgineer does, and its normalized gain over the stock robot is 1.00 against 0.76 for VLMgineer and 0.65 for CMA-ES. Under this rule CMA-ES no longer comes out ahead.

(g3S8, Sv8r) Longer evaluation horizon. Every final design, for L2D and for every baseline, is re-flown under a longer control search than the one the search optimizes against and judged on that flight. This exposes designs that score well on the short search episode but fail as the episode runs on, so all methods are compared on long-horizon performance under one horizon.

(D9SF, g3S8) Positioning. The contributions are re-centered on (1) one co-design framework across robots and tasks, (2) prompt to design grounded in measured physics, and (3) a training-free path from prompt to hardware. Related Work now states that Eureka, RoboMoRe and Debate2Create also separate the reward from an outer objective, and how L2D's judge differs.

(g3S8, Sv8r) What each run is given. The Experimental Protocol appendix now states, for every comparison, where the reward, judge, starting motion, controller settings and design space come from, and defines "no tuning" and "zero shot" in terms of sim-to-real deployment.

(D9SF, Sv8r) Physical realizability. A new appendix section lists the rules that keep motor, mass, inertia and geometry changes consistent, the FEA co-design step for printed parts, and what is validated only in simulation.

(D9SF, Sv8r) Hard and soft constraints (Sec. 2.2). Every constraint the prompt places on the body is hard: knobs outside the stated scope stay at stock, an additive scope permits only added material, and edits the prompt does not allow, such as re-rating a motor, are never proposed. Everything the prompt leaves open is a soft default, the scope of the robot family and a default range per knob group, which the search may widen when the best designs keep pressing against it. The user signs off both before the run and can turn any default into a hard constraint by stating it in the prompt.

(g3S8, Sv8r) Human involvement and prompt specification (Sec. 2, App. "Writing Prompts"). Given the robot's MJCF, the task scene and a prompt, L2D runs without further input; the user signs off the judge and the design space, and no reward code, knob ranges or planner settings are written by hand. The prompt must name one completion event observable in one episode, and may add how the task must not be done, one graded quantity in units and a design scope; empty slots are filled by defaults. The limitations now state what this specification cannot guarantee (Sec. 5): a signed-off judge can still be passed by a failing design, a pass need not be what the user meant, a badly scoped design space can yield designs that cannot be built, and the search performs better on a graded signal rather than a near-binary pass/fail.

(g3S8) Consistency. We removed the unfinished notes, made the pen-spin statements and the selection-start settings consistent across the text, and corrected the stock toss distance.

We have also made three broader changes.

Real world: Beyond the Go2 kick, we added the YAM arm scoop to show that the same prompt-to-hardware path generalizes from legged robots to manipulation.

Tasks: We added tasks across robot families to show that the loop generalizes, and now report the gain over the stock robot on all fifteen tasks.

Paper: All figures have been edited in the paper to show task diversity, FEA results, and real world deployment.

Best,

Authors of Language to Design

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.