💻 computer science

OpenGo: An OpenClaw-Based Robotic Dog with Real-Time Skill Switching

The paper introduces OpenGo, an OpenClaw-powered robotic dog built on Unitree's Go2 platform that enables real-time skill switching, autonomous validation, and self-learning through natural language instructions to adapt to complex tasks and dynamic environments.

Original authors: Hanbing Li, Xuewei Cao, Zhiwen Zeng, Yuhan Wu, Yanyong Zhang, Yan Xia

Published 2026-04-03

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Hanbing Li, Xuewei Cao, Zhiwen Zeng, Yuhan Wu, Yanyong Zhang, Yan Xia

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very smart, highly educated robot dog named OpenGo. This isn't just a pet; it's a worker that can do many different jobs, from walking over rough terrain to doing backflips or dancing.

However, there's a problem with most robot brains: they are either too rigid (they can only do one thing) or too chaotic (they try to "think" their way through every movement, which often leads to mistakes or dangerous actions).

OpenGo solves this by using a clever "Manager and Worker" system. Here is how it works, explained with some everyday analogies:

1. The "Skill Library" (The Toolbox)

Think of the robot's brain as having a giant, organized toolbox. Inside this toolbox are pre-made "skills" like "Walk," "Jump," "Climb Stairs," or "Dance."

The Old Way: Usually, a robot tries to figure out how to move its legs from scratch every time it wants to walk. It's like asking a human to invent the concept of "walking" every single time they take a step.
The OpenGo Way: The robot doesn't invent new moves on the fly. It just picks a tool from the box. Before a new tool (like a "Backflip") is put in the box, it is rigorously tested in a video game simulation to make sure it won't break the robot. This ensures that every move the robot makes is safe and proven.

2. The "Dispatcher" (The Project Manager)

This is the most important part. OpenGo uses a super-smart AI (a Large Language Model) to act as a Project Manager.

The Problem with Free-Thinking AI: If you ask a free-thinking AI to "Go dance," it might try to calculate the physics of every muscle twitch. It might get confused and tell the robot to "lift its leg 500 feet high," which is impossible and dangerous. This is called "hallucination" (making things up).
The OpenGo Solution: The Project Manager is strictly forbidden from inventing new moves. Its only job is to look at the toolbox and say: "Okay, the user wants a dance. I see the 'Dance' skill in the box. I will pick that one and tell the robot to do it at medium speed."
The Analogy: Imagine you are ordering food at a restaurant. You don't tell the chef, "Go to the farm, pick a tomato, slice it, and cook it." You just say, "I'll have the burger." The "burger" is the pre-made skill. The Project Manager ensures the robot only orders from the menu, never inventing a dish that doesn't exist.

3. The "Self-Learning" (The Feedback Loop)

OpenGo isn't just a dumb machine; it learns from its mistakes and your feedback.

How it works: If the robot tries to walk on snow and slips, or if you tell it via a chat app (like Feishu), "Hey, that was too fast, slow down," the system remembers this.
The Analogy: It's like a new employee. If they try a method and fail, or if their boss says, "Next time, do it this way," the employee updates their mental notes. The next time they face snow, they automatically choose a "slow and steady" setting instead of the "fast" one. It gets better over time without needing to be reprogrammed by a human engineer.

4. The Real-World Test

The researchers tested this on a real robot dog (the Unitree Go2).

The Result: You can talk to the robot through a simple chat app. You can say, "Go forward, then turn around, then do a backflip." The Project Manager breaks this down, picks the right tools from the toolbox, and the robot executes them smoothly.
The Catch: It's not instant. Because the "Project Manager" (the AI) has to think and check the toolbox, there is a tiny delay (a few seconds). It's like waiting for a human manager to read your email and reply, rather than a machine that reacts instantly. But this delay is a small price to pay for safety and intelligence.

Summary

OpenGo is a robot dog that combines the creativity of a human (understanding your language) with the safety of a machine (only doing pre-tested moves).

Instead of letting the robot "improvise" its movements (which is dangerous), it lets the robot improvise its choices. It's like having a jazz musician who can only play notes from a specific, safe scale, but can arrange those notes into an infinite number of beautiful songs based on what the audience asks for.

1. Problem Statement

The paper addresses the fundamental challenge of enabling embodied agents (specifically quadruped robots) to adapt to complex, dynamic environments and diverse tasks. Current limitations include:

Generalization vs. Specialization: While reinforcement learning (RL) controllers excel in specific terrains, they often fail in extreme conditions (e.g., snow, fog, partial occlusion) where perception is unreliable. Relying on a single general strategy is insufficient; robots need a repertoire of specific skills (walking, jumping, crouching).
The "Hallucination" Gap in LLM Control: While Large Language Models (LLMs) show promise in high-level planning, direct end-to-end reliance on LLMs for low-level robot control is dangerous. Unconstrained LLMs may generate linguistically reasonable but physically infeasible or unsafe plans (e.g., invalid skill calls or unsafe parameters), a phenomenon described as "practical hallucination."
Usability: Controlling robots typically requires expert knowledge, making it difficult for non-expert users to issue natural language commands that result in safe, successful execution.

2. Methodology: The OpenGo Framework

OpenGo is an embodied robotic dog pipeline built on the OpenClaw framework, deployed on a Unitree Go2 quadruped. It decouples high-level semantic reasoning from low-level execution by anchoring controllability in a structured skill library rather than unconstrained language generation.

The system consists of three tightly coupled components:

A. Customizable Skill Library

This serves as the foundation, providing a structured, reusable, and safe action space.

Structure: Each skill is a callable module defined by five fields:
1. Skill Head: Identifier and semantic label.
2. Parameters: Adjustable hyperparameters (e.g., speed, distance, angle) bounded within safe limits.
3. Constraints: Preconditions and safety boundaries (e.g., terrain requirements, actuator limits).
4. Function: The fixed, validated implementation code (immutable during online execution).
5. Prompts: Textual descriptions for the dispatcher.
Import Process: New skills undergo a rigorous two-stage validation: (1) Code review for interface compatibility and safety, and (2) Simulation-based validation for robustness. Only validated skills enter the library.
Design Principle: Separation of the fixed execution function from adjustable task configuration prevents the LLM from modifying low-level control logic directly.

B. The Dispatcher (LLM-Based)

The dispatcher acts as the high-level decision maker, translating human intent into executable skill sequences.

Inputs: Task description ( $T$ ), human instructions ( $I$ ), and perceived scenario state ( $S$ ).
Restricted Role: The LLM is not allowed to generate raw motor commands. Its role is strictly limited to:
1. Skill Selection: Choosing the appropriate skill(s) from the pre-validated library.
2. Parameter Assignment: Setting bounded hyperparameters based on the context.
Safety Mechanisms:
- Skill candidates are filtered by constraints before being presented to the LLM.
- Parameters are restricted to valid ranges defined in the skill template.
- A Memory/State Check module monitors execution history and robot state to ensure the next step is valid, enabling dynamic replanning if failures occur.

C. Self-Learning Framework

This module enables the system to improve over time without rewriting low-level control code.

Feedback Loop: It collects three types of feedback: task completion signals, error logs (failed calls, abnormal states), and human feedback (via a communication platform).
Adaptation:
- Dispatch Level: Adjusts the priority of skill selection based on success/failure patterns in specific scenarios (e.g., preferring a "crouch" skill over "walk" on slippery terrain).
- Parameter Level: Tunes default hyperparameters (e.g., step length) based on repeated execution outcomes.
Human-in-the-Loop: Non-expert users can provide natural language corrections or guidance via the Feishu communication platform, which the system integrates as supervisory data for future dispatching.

3. Key Contributions

Structured Skill Abstraction: OpenGo introduces a pipeline where LLMs operate over a validated, structured skill library rather than raw actions, significantly reducing the risk of "hallucinated" or unsafe behaviors.
Real-Time Skill Switching: The system demonstrates the ability to autonomously select and switch between diverse skills (e.g., walking, backflipping, dancing) based on real-time scene analysis and natural language instructions.
Accessible Human-Robot Interaction: By integrating with the Feishu platform, the system allows inexperienced users to control a complex quadruped robot using simple natural language, bridging the gap between semantic intent and physical execution.
Closed-Loop Self-Learning: The framework incorporates execution outcomes and human feedback to iteratively refine skill selection and parameterization, improving performance over time while maintaining safety constraints.

4. Results and Evaluation

The system was deployed on a real Unitree Go2 robot, with experiments focusing on feasibility, interaction, and latency.

Task Execution: The robot successfully executed complex commands such as "Move Forward," "Turn Around," "Backflip," and "Dance" based on natural language prompts.
System Latency Analysis:
- Single-Skill: Initial execution incurs higher latency due to "cold-start" overhead (LLM parsing, skill loading). Subsequent executions are faster due to caching. Latency increases with the number of input parameters.
- Multi-Skill Composition: Total response time does not scale linearly with the number of skills due to coordination overhead (state transitions, dependency resolution). However, the system successfully handles sequences of 2–4 instructions.
Human-Robot Interaction: The Feishu integration successfully enabled bidirectional communication, allowing users to monitor progress and provide corrections, significantly lowering the barrier to entry for robot control.

5. Significance and Future Work

Significance:
OpenGo presents a practical pathway for Embodied AI by reconciling the semantic flexibility of LLMs with the safety and robustness requirements of physical robotics. By constraining the LLM to a "skill selection and parameter tuning" role, the system achieves a balance between adaptability and controllability, making it suitable for real-world deployment where safety is paramount.

Limitations:

Latency: The decision pipeline suffers from noticeable delays due to LLM processing and skill initialization, which can hinder performance in highly dynamic, time-sensitive environments.
Motion Continuity: Transitions between discrete skills can appear fragmented, lacking the fluidity of continuous control policies.

Future Directions:
The authors plan to expand the skill library with complex modules (e.g., obstacle avoidance, navigation) and optimize the execution pipeline for smoother motion and reduced latency through skill preloading and more efficient parameter parsing.

In conclusion, OpenGo demonstrates that combining large language models with structured, validated skill systems is a viable and effective strategy for creating robust, adaptable, and user-friendly embodied agents.