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

Abstract: Adaptation to complex tasks and multiple scenarios remains a significant challenge for a single robot agent. The ability to acquire organize, and switch between a wide range of skills in real time, particularly in dynamic environments, has become a fundamental requirement for embodied intelligence. We introduce OpenGo, an OpenClaw-powered embodied robotic dog capable of switching skills in real time according to the scene and task instructions. Specifically, the agent is equipped with (1) a customizable skill library with easy skill import and autonomous skill validation, (2) a dispatcher that selects and invokes different skills according to task prompts or language instructions, and (3) a self-learning framework that fine-tunes skills based on task completion and human feedback. We deploy the agent in Unitree's Go2 robotic dog and validate its capabilities in self-checking and switching of skills autonomously. In addition, by integrating Feishu-platform communication, we enable natural-language guidance and human feedback, allowing inexperienced users to control the robotic dog through simple instructions.

• The paper introduces a modular framework that combines an LLM-based dispatcher with a pre-validated skill library to ensure safe, real-time skill switching on quadrupedal robots.
• It employs a self-learning mechanism to iteratively refine skill parameters using execution feedback, thereby enhancing system adaptability and reducing latency.
• The approach demonstrates improved safety, interpretability, and extensibility through structured, natural-language-based control on the Unitree Go2 platform.

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

Introduction

OpenGo addresses the critical problem of real-time, adaptive skill acquisition and switching in quadrupedal robots, a challenge driven by the increasing complexity and variability of real-world deployment scenarios. Recent advances in LLMs have demonstrated their utility as high-level semantic controllers in embodied systems but suffer from hallucination and incompatibility when deployed directly for action generation on physical robots. OpenGo introduces a hybrid framework that constrains LLM decision-making to the structured selection and parameterization of pre-validated skills, resulting in a robust, interpretable, and extensible system for natural-language-driven embodied intelligence.

Figure 1: Demonstration of LLM-driven skill execution and composition capabilities on the Unitree Go2 platform.

OpenGo Framework

The OpenGo architecture is modular, comprising three primary components: a customizable skill library, an LLM-based dispatcher, and a self-learning framework. The system is deployed on the Unitree Go2 quadruped platform, integrating both perceptual and control subsystems with a high-level communication layer via Feishu for natural language interaction.

Figure 2: The OpenGo framework, organized around a Dispatcher and Memory/State Check module with closed-loop feedback for robust skill execution.

Skill Library

The skill library grounds the set of possible actions executable by the robot. Skills are not directly authored by LLMs during deployment but rather pass through a multi-step vetting process: first generated via LLM programming interfaces, then subject to code review and automatic simulation-based validation. This ensures compatibility, safety, and adherence to hardware-specific constraints. Each skill entry contains structured metadata: a semantic identifier, tunable parameters, safety and validity constraints, a fixed execution function, and prompt descriptions.

Figure 3: Skill library organization and review/validation flow, highlighting the encapsulation of function, parameters, constraints, and prompts.

This separation of immutable implementation and parameterized configuration is fundamental, as it prevents the LLM—and by extension, user inputs via natural language—from circumventing safety boundaries or generating infeasible behaviors. It enables the rapid extension of the action space through skill addition without system-level reengineering.

Dispatcher

The dispatcher module interfaces with LLMs to convert high-level user instructions, environmental state, and task descriptions into actionable skill sequences. Critically, it restricts LLM outputs to the validated skill space, enabling only skill selection and parameter assignment within pre-specified bounds. This mitigates risks from typical LLM pitfalls in robotics such as invalid action sequences or hallucinated transitions. The dispatcher maintains closed-loop interaction through a Memory/State Check module, leveraging execution feedback and current robot state to implement dynamic replanning and skill precondition enforcement.

Figure 4: Dispatcher mechanism: LLM takes in task, instructions, and scene context to schedule skill sequences with dynamic feedback and replanning.

Self-Learning Framework

OpenGo includes a self-learning mechanism that iteratively improves skill selection and parameterization based on execution success, failure signals, and explicit or implicit human feedback. Rather than end-to-end policy retraining or online code synthesis, the self-learning pipeline adjusts preferences for skill invocation and hyperparameter defaults within the tested skill library. This formalizes long-term adaptability while preserving the guarantees of structural safety and interpretability.

Human–Robot Interaction

Natural language control and feedback are enabled via integration with the Feishu platform. Users can specify tasks, refine ongoing instructions, or provide corrections through conversational interfaces. The system transparently conveys execution status, completion confirmations, and error messages back to users. This interface democratizes access to quadruped robots, making complex instruction composition feasible for non-experts without sacrificing controllability.

Experimental Evaluation

Deployment on the Unitree Go2 demonstrates OpenGo's efficacy across several axes: skill generation, deployment robustness, and closed-loop human interaction. Skills generated through the LLM-prompted pipeline are subject to rigorous verification before real-world activation, substantially reducing the risk of infeasible commands and mechanical errors.

Latency Analysis

Responsiveness was quantitatively analyzed with respect to both single-skill and multi-skill compositional execution. Initial invocation of a skill suffers from cold-start latency due to LLM parsing and module instantiation, while repeated execution benefits from caching and skill loading optimizations. Latency also scales with the complexity (parameterization) of each skill.

Figure 5: Latency for single-skill execution, showing higher initial overhead with subsequent reduction via caching.

For multi-step tasks, coordination overhead introduces non-linear latency growth, especially as the pipeline resolves dependencies, scene transitions, and parameter bindings. System profiling reveals that optimizing preloading strategies and parameter parsing efficiency could further improve temporal performance, a critical requirement for time-sensitive robotic tasks.

Figure 6: System latency for multi-skill tasks, illustrating compounded response time with increased instruction complexity and quantity.

Implications and Future Directions

OpenGo substantiates the practical viability of constraining LLMs to operate over pre-validated and structured skill libraries, rather than generating end-to-end control or policies. This architecture yields significant improvements in safety, controllability, interpretability, and human accessibility for embodied AI. The modular skill library structure enables continual capability expansion, while the self-learning pipeline induces long-term adaptability without undermining the underlying safety guarantees.

Immediate system limitations involve the inherent inference latency of LLMs and the discrete nature of skill sequencing, which can impede fine-grained temporal smoothness in complex, high-frequency control regimes. These issues point toward the need for methods that optimize cold-start performance, skill preloading, and perhaps hybrid architectures integrating fast local controllers with high-level LLM-based strategy orchestration.

Looking forward, extending the skill library with advanced perceptual, navigation, and interaction primitives will further enhance autonomy in dynamic, unstructured environments. The OpenGo framework's approach can be generalized to other classes of mobile and manipulator robots, serving as a reference pipeline for operationalizing language-driven embodied agents in practical deployments.

Conclusion

OpenGo presents a rigorously validated blueprint for the synthesis of LLM-based semantic reasoning with safe, interpretable, and extensible low-level skill composition in embodied robotics (2604.01708). By modularizing skill execution and strictly formalizing the contract between high-level language interfaces and robot-compatible actions, OpenGo resolves fundamental challenges of safety and efficiency in natural-language-driven robot control. This work establishes concrete directions for future research at the intersection of scalable language-grounded reasoning, robust skill system design, and adaptive embodied AI.