Lang2Morph: Language-Driven Morphological Design of Robotic Hands
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.
Rosa: We're looking at the paper: "Lang2Morph: Language-Driven Morphological Design of Robotic Hands".
Dev: Here's the gist of the paper. Designing robotic hand morphologies for diverse manipulation tasks requires balancing dexterity, manufacturability, and task-specific functionality<ref:2509.18937#pg2> In this paper, we present Lang2Morph, a language-driven pipeline for robotic hand design<ref:2509.18937#pg3>.
Rosa: The single most informative sentence about the paper's subject and finding is that Lang2Morph generates fabricable, task-adaptive morphologies directly from natural language task description<ref:2509.18937#pg5>.
Dev: Pruning redundant reasoning tokens Lang2Morph is a pipeline that translates natural language task descriptions into fabricable robotic hand morphologies<ref:2509.18937#pg5>.
Rosa: The pipeline consists of two main stages: (i) Morphology Design, which maps tasks into semantic tags, structural grammars, and OPH-compatible parameters; and (ii) Selection and Refinement, which evaluates design candidates based on semantic alignment and size compatibility<ref:2509.18937#pg5>.
Title and authors: Rosa: So we're looking at a paper called Lang2Morph that's about using large language models to design robotic hands from just a natural language description of what you want the hand to do. It’s basically taking a sentence like "design a hand for holding this heavy bottle" and turning it into something you can actually three dee print <ref:2509.18937#pg1>.
Dev: Right, Rosa. It’s interesting because most existing tools rely on people figuring out the design by looking at examples or using physics simulations, which can be slow and expensive. This Lang2Morph paper aims to replace that manual tuning with this language-driven pipeline that maps text directly into something usable by the Open Parametric Hand framework.
Taro: I wonder if this works outside of a controlled lab setting. If we're talking about real manipulation, does having a design generated from text mean it will actually perform well when things get messy?
Rosa: That’s the million-dollar question for me. The authors show that they built two main stages: first, morphology design where the LLM turns your task into semantic tags and structural grammars, and second, selection and refinement where the system checks if those designs actually make sense for each other in terms of size and task requirements.
Dev: And what’s really smart about their approach is that they avoid needing physics simulation or expert heuristics to get there. They use the LLM's ability to reason about task semantics—like identifying object properties or grasp types—to create the symbolic structure first, and then they validate that structure against the Open Parametric Hand rules before generating any CAD geometry.
Taro: So it’s not just guessing shapes; it’s using language to build a blueprint that has to pass a structural check based on physical limits before it even gets rendered as a three dee model <ref:2509.18937#pg1>. That seems like a solid way to handle the complexity of hand design.
Rosa: Exactly. They show that this method consistently improves what they call the Morphology Validity Rate, which is basically how often their generated designs pass all the necessary rules for being physically realizable before they move on to actual computer-aided design rendering. The results across different large language models suggest it’s more reliable than just random sampling or zero-shot prompting.
Dev: And looking at those results, the distribution of the designs they generate isn't random; they see clear clusters forming for different grasp types that line up with what the task actually requires semantically. That means you don't get a jumble of shapes; you get shapes that are functionally related to your instruction.
Title and authors: Taro: That clustering is important because it shows the LLM is learning a kind of structure in the design space itself, not just producing random outputs that happen to work sometimes. It suggests the language input actually guides the system toward a meaningful solution path.
Rosa: And they also have this step where they filter those initial designs by enforcing specific morphological constraints derived from things like three dee printing practices and the Open Parametric Hand framework before moving to final geometry parameterization <ref:2509.18937#pg1>. This keeps the outputs constrained, which is vital for manufacturability.
Dev: It’s a two-stage process that handles both the abstract structure and the concrete geometry parameters. They condition those final geometric details on a selected structural hypothesis and its semantic tags, making sure everything fits together logically before you get to rendering.
Taro: I’m curious about how they handle variation. If I ask for one task, how do they make sure that when I tweak the prompt slightly—maybe asking for a hand that can also stabilize something—they don't just give me a slightly different version of the exact same shape?
Rosa: They introduce a diversity strategy during the grammar generation phase where they prompt the LLM with variant-specific design cues. This is supposed to ensure that even for the same core task, you get structurally distinct candidates, giving you a richer pool to choose from later.
Dev: That feedback mechanism is key too. They show blue dashed arrows in their pipeline representing refinement based on semantic alignment and size compatibility, which means if the design doesn't meet the size constraints for a heavy lift, it can be fed back into the LLM to suggest changes, like making the fingers thicker.
Taro: That sounds like an iterative loop that’s guided by understanding what’s functionally right versus what's structurally possible. It moves beyond just generating one thing; it seems to explore the design space intelligently based on feedback.
Rosa: And they have this heuristic approximation called a morphology-based Grasp Force Level, or GFL, which acts as a proxy for grasp strength. They find that higher average GFL scores show up for force-based tasks, which makes sense because those tasks actually need strong, stable grasps to succeed.
Dev: That’s an interesting move because it’s not a pure physics simulation; it’s a heuristic based on the generated structure itself. It helps them estimate structural support without needing a full dynamic simulation for every single design idea they test.
Title and authors: Taro: So, if we think about real-world failure modes, this GFL heuristic gives us a quick way to judge if a proposed morphology is likely to fail under force requirements before we even try to run complex control loops on it.
Rosa: That’s the practical side of it. In terms of what this changes for people who just listen to the show, it means that instead of spending months manually tweaking parameters for a new gripping task, you could describe what you want and get a set of physically valid, task-adapted hand designs generated very quickly.
Dev: It shifts the focus from low-level parameter tuning to high-level semantic reasoning by the LLM. The implication is that we can move toward designing complex robotic hands faster than current expert methods allow.
Taro: I just hope that when we apply these language-driven designs to actual robots, they don't have hidden failure modes that only show up when the world misbehaves in a way the prompt didn't account for.
Rosa: That’s what we need to watch for. The paper shows strong structural validity and task separability across different grasp types, but as always with any generative method, you still need to test those generated hands under real stress conditions.
Dev: So to wrap up this discussion on Lang2Morph, it’s a pipeline that uses LLMs for semantic mapping into symbolic structures, followed by grammar generation and validation against OPH constraints to create fabricable morphologies directly from natural language. It shows how task decomposition and constraint-aware parameterization can significantly boost design validity compared to simpler methods.
Taro: I think the key value here is using the LLM as a structural reasoner rather than just a pattern matcher for existing designs. It’s about building a grammar that respects physical rules while understanding the high-level goal.
Rosa: It's promising because it removes some of the heavy lifting from simulation and expert tuning, allowing us to explore a much larger design space guided by our understanding of what the task demands semantically.
Dev: For real-time control systems, this means we can feed these LLM-generated structures into our systems with higher confidence that they fit within the operational envelopes we define based on those morphological constraints.
Taro: So, for now, it's a powerful design tool that creates candidates; the next step is always testing those candidates robustly in an environment where things don't go exactly as described in the prompt.
Rosa: Right. That’s what we’ve got on Lang2Morph for today. We’ll keep watching how this pipeline evolves and what it means for building smarter, more adaptable robotic systems.
The paper's summary: Rosa: So, Lang2Morph is essentially this pipeline that takes you just a sentence about what you want a robotic hand to do, and it spits out something you can actually build in three dee print format.
Dev: Right. It's about using large language models to translate those natural language task descriptions into the specific symbolic structures and parameters needed for a hand design system like Open Parametric Hand.
Rosa: The main finding is that this process works really well, and it doesn't just give you random shapes; it generates designs that are actually valid, meaning they pass all the physical and structural rules before you even get to the computer-aided design rendering stage.
Dev: It uses a two-stage approach where the AI first analyzes your task to create a semantic schema—like understanding what object properties matter or what kind of grasp you need—and then it generates a structure grammar that has all the necessary component and connection rules.
Rosa: And then there's this refinement stage where it checks those initial designs against size compatibility and semantic alignment, which means if a finger is too long for the task, the system flags it or suggests an adjustment.
Dev: What’s interesting from my side is how they handle uncertainty; they don't rely on heavy physics simulations to find solutions, but instead use this morphology-based Grasp Force Level heuristic as a way to quickly estimate if a structure will be strong enough for the task you described.
Rosa: They also showed that by using variant-specific design cues when generating the grammar, the system produces structurally distinct designs even for similar tasks, which gives you a richer set of options to choose from later.
Dev: It's pretty neat because it moves the heavy lifting away from manual tuning and simulation and puts it into a language-driven pipeline that checks validity automatically against fabrication constraints.
Rosa: But we have to ask, does this work when things get messy in the real world? Does this generated hand actually handle unexpected objects or unpredictable movements outside of a perfectly controlled test bed?
Dev: That’s the million-dollar question for me. The authors show strong performance within their testing environment, but whether it can gracefully recover when the world doesn't behave exactly as described in your prompt is what we need to see next.
The paper's improvements: Rosa: Lang2Morph isn't just about generating one hand shape; it suggests a whole way of improving design by using this language pipeline to actively refine candidates based on real performance metrics.
Dev: Exactly, Rosa. The paper points out that the system can use feedback from those morphological constraint checks and semantic alignment to guide the next generation of designs, which is basically an iterative loop for better results.
Rosa: It's not just about getting a valid shape once; it's about making sure the design space explored by the AI gets smarter with every iteration based on how well it meets those task requirements.
Dev: And they introduce this idea of exploring structural diversity during the initial grammar generation, using variant-specific cues to ensure that different designs are generated even when tackling the same general task.
Rosa: That means instead of getting stuck in one kind of shape, you get a wider variety of possibilities aligned with your needs right from the start, which helps cover more ground in your design exploration.
Dev: I see how that relates to real-time control; having a richer pool of candidates means when you finally pick one to run, it has a better chance of being functionally appropriate for the loop rate you’re running.
Rosa: So it's moving beyond just a first guess and making the AI actively seek out different structural solutions that fit your high-level goal, which is what makes me excited about this pipeline.
Dev: It really shows how combining semantic reasoning with constraint enforcement allows the AI to navigate the design space in a way that respects both what you want and what's physically possible.
Rosa: But we still have to worry about those real-world failures, right? If Lang2Morph generates a shape that works perfectly in simulation but fails when it hits something unexpected, does this refinement loop catch that kind of unpredictable failure?
Dev: That’s the sticking point for me. The paper focuses heavily on morphological validity and task separability within their testing framework, but we need to know if this method has a robust safety case when things go sideways in actual manipulation scenarios.
Conclusion: Rosa: So to wrap up, Lang2Morph is an AI pipeline that uses natural language to automatically generate robot hand designs that are structurally valid and task-aligned without needing complex simulations or expert tuning.
Dev: It shows that you can use LLM reasoning to handle the abstract part—the task understanding and the structural grammar—and then have a rigorous validation process check it against real physical limits.
Rosa: The big implication is that this could drastically speed up the process of creating custom, task-specific hands for field robotics, moving us away from slow manual tuning toward language-driven design.
Dev: I agree on the speed aspect. If we can generate a valid morphology quickly, then our real-time control loops have a much better starting point for testing latency and failure modes in practice.
Taro: From my research side, what interests me is how gracefully this AI handles the inevitable surprises that happen when a hand interacts with something outside the perfect description you gave it initially.
Rosa: That's fair. We're still looking at whether these designs hold up when the world throws unexpected objects or unpredictable forces at them in a real field test environment.
Dev: The paper itself is focused on the design phase, so they don't solve the entire control problem, but they give us a much better starting morphology to work with than we currently have for complex manipulation.
Taro: It’s a solid step toward building more adaptable robotic systems that don't need every single task pre-programmed into their physical design from scratch.
Rosa: So that’s the summary of Lang2Morph, a language-driven approach to morphological design that uses AI to bridge the gap between natural language and fabricable robot structures.
Dev: It’s a powerful tool for morphology generation, but we still have to focus on how reliably those generated morphologies perform when we push them into real-time execution loops with high demands.
Taro: Next time, we’ll want to see if these hand designs can actually handle the kind of dynamic, unpredictable interactions that make field work so challenging for autonomous systems.
Yanyuan Qiao, Kieran Gilday, Yutong Xie, Josie Hughes
Swiss Federal Institute of Technology Lausanne (EPFL) · Mohamed bin Zayed University of Artificial Intelligence (MBZUAI)
cs.RO
Submitted: 2025-09-23
Updated: 2026-11-07
License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
Importance score: 90/100
The gist: Designing robotic hand morphologies for diverse manipulation tasks requires balancing dexterity, manufacturability, and task-specific functionality<ref:2509.18937#pg2> In this paper…
Key concepts
- Dual-Level Task Analysis
- This involves two steps where the LLM first understands the natural language intent to create a semantic schema (encoding task knowledge like object properties) and then generates a structural grammar (defining component rules and spatial layouts). This ensures the design captures both what needs to be done and how it should be built.
- Morphological Validity Rate (MVR)
- MVR measures how many generated hand designs successfully pass all necessary physical and structural checks before being sent for 3D printing. Higher MVR indicates that the LLM is effectively generating physically realizable and structurally sound hand shapes that meet the task requirements.
- Grasp Force Level (GFL)
- This is a heuristic estimate used to approximate how strong a generated hand structure will be for a specific task. It serves as a non-physical proxy for grasp strength, helping the system select morphologies that are structurally capable of handling required forces, especially for force-based manipulation tasks.
Terminology
Summary
Designing robotic hand morphologies for diverse manipulation tasks requires balancing dexterity, manufacturability, and task-specific functionality<ref:2509. p. 018937#pg2> In this paper, we present Lang2Morph, a language-driven pipeline for robotic hand design<ref:2509. p. 018937#pg3>. The single most informative sentence about the paper's subject and finding is that Lang2Morph generates fabricable, task-adaptive morphologies directly from natural language task description<ref:2509.18937#pg5>.
Pruning redundant reasoning tokens
Lang2Morph is a pipeline that translates natural language task descriptions into fabricable robotic hand morphologies<ref:2509.18937#pg5>. The pipeline consists of two main stages: (i) Morphology Design, which maps tasks into semantic tags, structural grammars, and OPH-compatible parameters; and (ii) Selection and Refinement, which evaluates design candidates based on semantic alignment and size compatibility<ref:2509. p. 018937#pg5>. This modular framework removes the need for expert heuristics or physics-based simulation while ensuring that outputs are task-relevant and physically realizable<ref:2509. p. 118937#pg5>.
How the training signal is built
The core of the pipeline is an LLM-powered design stage that maps natural-language task descriptions into symbolic and geometric representations of robotic hands<ref:2509.18937#pg5>. This stage involves several steps:
-
Dual-Level Task Analysis, which includes Semantic Schema Generation where the LLM translates the natural language intent T into a structured semantic schema F=fLLM(T)<ref:2509.18937#pg5>. This schema encodes task-relevant knowledge such as Task understanding, Object property extraction, and Grasp type classification<ref:2509. p. 218937#pg5>.
-
Structure Grammar Generation, where the LLM is prompted to output a JSON-style grammar that includes Component definitions, Structure rules, Connection rules, and Spatial layout and actuation hints<ref:2509.18937#pg5>.
-
Automatic Validation and Revision, which employs a hybrid validation pipeline integrating Rule-based validation with LLM-based structural assessment to verify the generated grammar S satisfies the structural requirements for the OPH<ref:2509.18937#pg5>.
-
Geometry Parameterization, where conditioned on the selected structural hypothesis S∗ and semantic tags F, the LLM generates a structured dictionary θ that defines all required parameters for CAD rendering<ref:2509.18937#pg5>.
Where the gains come from
The gains in design validity are demonstrated by evaluating Morphological Validity Rate (MVR), which measures the proportion of generated candidates that pass all morphological constraint checks before CAD rendering<ref:2509.18937#pg5>. The results show that Lang2Morph consistently improves validity across all tested LLMs by leveraging task decomposition, symbolic grammar, and constraint-aware parameterization<ref:2509. p. 518937#pg5>. Specifically, Table I shows that Lang2Morph achieves notably higher Morphology Validity Rates (MVR) compared to both random sampling and zero-shot prompting baselines<ref:2509. p. 518937#pg5>. Furthermore, the distribution of generated designs reveals clear structure in the design space, with grasp types forming distinguishable clusters aligned with task semantics<ref:2509. p. 518937#pg5>.
Morphological Constraint Filtering and Diversity
Before translating parameters into CAD geometry, a morphological constraint filtering step enforces a set of design rules inherited from the OPH framework and typical 3D-printing practices<ref:2509.18937#pg5>. These checks include limits on finger count, joint and link dimensions, slenderness ratios, overall finger length, initial orientations, and fabrication footprint<ref:2509. p. 418937#pg5>. To ensure structural distinctness among variants for the same task, a diversity strategy is introduced during grammar generation by prompting the LLM with variant-specific design cues<ref:2509. p. 318937#pg5>. This mechanism underpins the multi-variant design process, providing a richer candidate pool for downstream ranking and feedback<ref:2509. p. 418937#pg5>.
Grasp Capability Estimation and Qualitative Results
To estimate structural support, a morphology-based Grasp Force Level (GFL) is proposed as a heuristic approximation of grasp strength<ref:2509.18937#pg5>. Higher average GFL scores are achieved for force-based tasks, aligning with their need for strong, stable grasps<ref:2509. p. 618937#pg5>. Qualitative results illustrate how the generated hand structures adapt to functional demands; for example, the design for holding a household bottle features a wide palm and robust fingers that support lifting and enclosing large objects<ref:2509. p. 618937#pg5>. These examples suggest that the model can produce structurally varied and functionally appropriate designs in response to different task descriptions without relying on predefined templates<ref:2509. p. 718937#pg5>.
Conclusion
We proposed Lang2Morph, a language-driven pipeline that automatically generates robotic hand morphologies from natural-language task descriptions<ref:2509.18937#pg5>. By combining LLM-based semantic reasoning, grammar-guided structure generation, and validation and feedback, our method produces diverse, valid, and task-aligned designs without relying on simulation or expert tuning<ref:2509. p. 718937#pg5>. Experiments across different task descriptions demonstrate that Lang2Morph achieves high structural validity, strong task separability, and meaningful variation across grasp types<ref:2509. p. 718937#pg5>. While our current focus is on morphology design, the pipeline is readily extensible<ref:2509. p. 718937#pg5>.
REFERENCES
[1] L. Odhner, L. P. Jentoft, M. p. 7 R. Claffee, N. p. 7 Corson, Y. Tenzer, R. R. Ma, M. Buehler, R. p. 7 C. Kohout, R. D., Howe and A. p. 7, “A compliant hand for robust manipulation,” The International Journal of Robotics Research
[2] H., P., N., G., and other authors, “Multisensory five-finger dexterous hand: The dlr/hit hand ii,” in Proc. p. 7 IEEE/RSJ Int. p. 7 Conf. on Intelligent Robots and Systems, 2008
[3] R. R., L., M., N., Y., R. R. Ma, and A. M., “A modular, open-source 3d printed underactuated hand,” in Proc. p. 7 IEEE Int. Conf. on Robotics and Automation, 2013
[4] R. R., A. M., “Yale openhand project: Optimizing open-source hand designs for ease of fabrication and adoption,” IEEE Robotics & Automation Magazine, vol. p. 7 24, no. 1, pp. 32–40, 2017
[5] K., C., F., and J. Hughes, “Embodied manipulation with past and future morphologies through an open parametric hand design,” Science Robotics, 2025
[6] N., R. MacCurdy, J. p. 7 Clune, and H. p. 7 Lipson, “Unshackling evolution: evolving soft robots with multiple materials and a powerful generative encoding,” in Proc. p. 7 Genetic and Evolutionary Computation Conference. p. 7 ACM, 2013
[7] A., J., M., J., A. Spielberg, D. p. 7 Rus, and W. p. 7 Matusik, “Robogrammar: Graph grammar for terrainoptimized robot design,” ACM Trans. p. 7 Graph. (SIGGRAPH), vol. p. 7 39, no. 6, pp. 188:1–188:16, 2020
[8] Y., S., M., X., Y., M., X., and W. Yang, “Task2morph: Differentiable task-inspired framework for contactaware robot design,” in Proc. p. 7 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2023, pp. p. 7 452–459
[9] R., Z. S., J., B., and B. Chen, “Text2robot: Evolutionary robot design from text descriptions,” 2025 IEEE International Conference on Robotics and Automation, pp. p. 7 5789–5797, 2024
[10] M., A., N., Y. Chebotar, O. p. 7 Cortes, B. David, C. Finn, K. Gopalakrishnan, K. p. 7 Hausman, A. p. 7, D., J.-H., J.-I., B.-I., E. Jang, R. M. J.: “Do as i can, not as i say: Grounding language in robotic affordances,” in Conference on Robot Learning, 2022
[11] D., F., M. S., C. Lynch, A. Chowdhery, B. p. 7 Ichter, A. Wahid, J. Tompson, Q. p. 7 H., T., W.-H., Y.-C., P.-Sermanet, D. p. 7: “Palm-e: An embodied multimodal language model,” in International Conference on Machine Learning, 2023
[12] Y. Du, S. Chen, W. Zan, P. Li, M., D., B., Y.-H., and B. Wang, “Blenderllm: Training large language models for computeraided design with self-improvement,” arXiv:2412. p. 714203, 2024
[13] J., W., X., Y.-L., G. Zhou, and X. p. 7 Zhou, “Cad-llama: Leveraging large language models for computer-aided design parametric 3d model generation,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, 2025
[14] M., G., E. Farnioli, A. p. 7 Serio, C. Piazza, and A. p. 7 Bicchi, “Adaptive synergies for the design and control of the pisa/iit softhand,” The International Journal of Robotics Research, 2014
[15] R., O., “A novel type of compliant, underactuated robotic hand for dexterous grasping,” The International Journal of Robotics Research, 2016
[16] Z. K. Weng, “Bidexhand: Design and evaluation of an open-source 16-dof biomimetic dexterous hand,” arXiv:2504. p. 714712, 2025
[17] C. C., M. Eberlein, F. p. 7 Katsimalis et al. p. 7, “Orca: An opensource, reliable, cost-effective, anthropomorphic robotic hand for uninterrupted dexterous task learning,” arXiv:2504. p. 704259, 2025
[18] G., Y. Hong, and Q. p. 7 Wu, “Navgpt: Explicit reasoning in vision-and-language navigation with large language models,” in AAAI Conference on Artificial Intelligence, 2023
[19] Y. Qiao, W. Lyu, H. Wang, Z. Wang, Z. Li, Y. Zhang, M. Tan., and Q. Wu., “Open-nav: Exploring zero-shot vision-and-language navigation in continuous environment with open-source llms,” 2025 IEEE International Conference on Robotics and Automation, pp. p. 7 6710–6717, 2024
[20] X., M., Y. Geng, H. Geng, Y. Long, Y. Shen, R., J.-L., and H.-D.: “Manipllm: Embodied multimodal large language model for object-centric robotic manipulation,” IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. p. 7 18 061–18 070, 2023
[21] R. Carlet, K. Gilday, and J. p. 0 Hughes, “Behaviour range optimization of the dexterous robotic open parametric hand,” in 2025 IEEE 8th International Conference on Soft Robotics. p. 7 IEEE, 2025, pp. p. 7 1–7
[22] M. R., “On grasp choice, grasp models, and the design of hands for manufacturing tasks,” IEEE Transactions on Robotics and Automation, vol. p. 7 5, no. 3, pp. 269–279, 1989
[23] T., J., H.-B. Schmiedmayer, A. p. 7 M., Dollar, and D. p. 7 Kragic, “The grasp taxonomy of human grasp types,” IEEE Transactions on Human-Machine Systems, vol. p. 7 46, no. 1, pp. 66–77, 2016
[24] T. L., “Evidence in hand: recent discoveries and the early evolution of human manual manipulation,” Philosophical Transactions of the Royal Society B: Biological Sciences, vol. p. 7 370, no. 1682, p. 20150105, 2015
[25] A. L., “Principal component analysis (pca),” Encyclopedia of Autism Spectrum Disorders, 2014 [Online]. p. 7 Available: https://api. p. 7semanticscholar. p. 7
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Improve task-specific robotic hand design by using LLMs to translate natural language task descriptions into symbolic structures and OPH-compatible parameters, enabling 3D-printable task-specific morphologies.
-
Enable scalable, task-conditioned morphology generation by combining LLM reasoning with a two-stage pipeline that includes dual-level task analysis (semantic and structural), geometry parameterization, and constraint validation.
-
Enhance design validity and diversity by implementing a multi-variant generation process where the LLM evaluates candidates based on semantic alignment and size compatibility, allowing for refinement based on feedback.
-
Increase the robustness of morphological design by incorporating a morphology-based Grasp Force Level (GFL) heuristic as a non-physical, morphologydriven proxy to estimate structural readiness for different tasks.
-
Improve the exploration of the design space by using LLMs with variant-specific design cues during grammar generation to ensure that generated designs are structurally distinct while preserving functional requirements.
Sources
- BlenderLLM: Training Large Language Models for Computer-Aided Design with Self-improvement
- BiDexHand: Design and Evaluation of an Open-Source 16-DoF Biomimetic Dexterous Hand
- ORCA: An Open-Source, Reliable, Cost-Effective, Anthropomorphic Robotic Hand for Uninterrupted Dexterous Task Learning
Related papers
- Rethinking Actions: Continuity-Aware Priors for World-Model Planning
- MOSAIC: Modular Obstacle and Spatial-Aware Framework for Manipulation In Cluttered Scenes
- SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning
- DexSeed: Expanding Human Hand-Object Interactions into Robot Demonstrations for Dexterous Policy Learning
- LaST0.5: A Generalist World Action Model with Interaction-Centric Latent Reasoning
- CIALLO: Learning Shared Intent Representations for Cross-Embodiment Manipulation