Initial release of ClawBody

Give your OpenClaw AI agent a physical robot body with Reachy Mini.

Features:
- Real-time voice conversation via OpenAI Realtime API
- OpenClaw/Clawson intelligence for AI responses
- Vision through robot camera
- Expressive movements (head, emotions, dances)

.env.example

@@ -0,0 +1,39 @@
+# ClawBody Configuration
+# Give your OpenClaw AI agent a physical robot body!
+
+# ==============================================================================
+# REQUIRED: OpenAI API Key
+# ==============================================================================
+# Get your key at: https://platform.openai.com/api-keys
+# Requires Realtime API access
+OPENAI_API_KEY=sk-your-openai-key
+
+# ==============================================================================
+# REQUIRED: OpenClaw Gateway
+# ==============================================================================
+# The URL where your OpenClaw gateway is running
+# If running on the same machine as the robot, use the host machine's IP
+OPENCLAW_GATEWAY_URL=http://192.168.1.100:18789
+
+# Your OpenClaw gateway authentication token
+# Find this in ~/.openclaw/openclaw.json under gateway.token
+OPENCLAW_TOKEN=your-gateway-token
+
+# Agent ID to use (default: main)
+OPENCLAW_AGENT_ID=main
+
+# ==============================================================================
+# OPTIONAL: Voice Settings
+# ==============================================================================
+# OpenAI Realtime voice (alloy, echo, fable, onyx, nova, shimmer, cedar)
+OPENAI_VOICE=cedar
+
+# OpenAI model for Realtime API
+OPENAI_MODEL=gpt-4o-realtime-preview-2024-12-17
+
+# ==============================================================================
+# OPTIONAL: Features
+# ==============================================================================
+# Enable/disable features (true/false)
+ENABLE_CAMERA=true
+ENABLE_OPENCLAW_TOOLS=true

.gitignore

@@ -0,0 +1,62 @@
+# ClawBody .gitignore
+
+# Environment and secrets
+.env
+*.env.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Logs
+*.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Package manager
+uv.lock

CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing to Reachy Mini OpenClaw
+
+Thank you for your interest in contributing! This project welcomes contributions from the community.
+
+## How to Contribute
+
+### Reporting Bugs
+
+If you find a bug, please open an issue with:
+- A clear title and description
+- Steps to reproduce the issue
+- Expected vs actual behavior
+- Your environment (OS, Python version, robot model)
+
+### Suggesting Features
+
+Feature requests are welcome! Please open an issue with:
+- A clear description of the feature
+- Use cases and motivation
+- Any technical considerations
+
+### Pull Requests
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Add tests if applicable
+5. Run linting: `ruff check . && ruff format .`
+6. Commit your changes (`git commit -m 'Add amazing feature'`)
+7. Push to the branch (`git push origin feature/amazing-feature`)
+8. Open a Pull Request
+
+## Development Setup
+
+```bash
+# Clone your fork
+git clone https://github.com/YOUR_USERNAME/reachy_mini_openclaw.git
+cd reachy_mini_openclaw
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+ruff check --fix .
+ruff format .
+```
+
+## Code Style
+
+- Follow PEP 8
+- Use type hints
+- Write docstrings for public functions and classes
+- Keep functions focused and small
+
+## Where to Submit Contributions
+
+### This Project
+Submit PRs directly to this repository for:
+- Bug fixes
+- New features
+- Documentation improvements
+- New personality profiles
+
+### Reachy Mini Ecosystem
+- **SDK improvements**: [pollen-robotics/reachy_mini](https://github.com/pollen-robotics/reachy_mini)
+- **New dances/emotions**: [reachy_mini_dances_library](https://github.com/pollen-robotics/reachy_mini_dances_library)
+- **Apps for the app store**: Submit to [Hugging Face Spaces](https://huggingface.co/spaces)
+
+### OpenClaw Ecosystem
+- **New skills**: Submit to [MoltDirectory](https://github.com/neonone123/moltdirectory)
+- **Core OpenClaw**: [openclaw/openclaw](https://github.com/openclaw/openclaw)
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the Apache 2.0 License.

LICENSE

@@ -0,0 +1,191 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no theory of
+      liability, whether in contract, strict liability, or tort
+      (including negligence or otherwise) arising in any way out of
+      the use or inability to use the Work (even if such Holder or
+      other party has been advised of the possibility of such damages),
+      shall any Contributor be liable to You for damages, including any
+      direct, indirect, special, incidental, or consequential damages of
+      any character arising as a result of this License or out of the use
+      or inability to use the Work (including but not limited to damages
+      for loss of goodwill, work stoppage, computer failure or malfunction,
+      or any and all other commercial damages or losses), even if such
+      Contributor has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024 Tom
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,212 @@
+---
+title: ClawBody
+emoji: 🦞
+colorFrom: red
+colorTo: purple
+sdk: static
+pinned: false
+short_description: Give your OpenClaw AI a physical robot body
+tags:
+ - reachy_mini
+ - reachy_mini_python_app
+ - openclaw
+ - clawson
+ - embodied-ai
+---
+
+# 🦞🤖 ClawBody
+
+**Give your OpenClaw AI agent a physical robot body!**
+
+ClawBody combines OpenClaw's AI intelligence with Reachy Mini's expressive robot body, using OpenAI's Realtime API for ultra-responsive voice conversation. Your OpenClaw assistant (Clawson) can now see, hear, speak, and move in the physical world.
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+
+## ✨ Features
+
+- **🎤 Real-time Voice Conversation**: OpenAI Realtime API for sub-second response latency
+- **🧠 OpenClaw Intelligence**: Your responses come from OpenClaw with full tool access
+- **👀 Vision**: See through the robot's camera and describe the environment
+- **💃 Expressive Movements**: Natural head movements, emotions, dances, and audio-driven wobble
+- **🦞 Clawson Embodied**: Your friendly space lobster AI assistant, now with a body!
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     Your Voice / Microphone                      │
+└─────────────────────────────┬───────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                    Reachy Mini Robot                             │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
+│  │ Microphone  │  │   Camera    │  │   Movement System       │  │
+│  │  (input)    │  │  (vision)   │  │ (head, antennas, body)  │  │
+│  └──────┬──────┘  └──────┬──────┘  └────────────▲────────────┘  │
+└─────────┼────────────────┼──────────────────────┼───────────────┘
+          │                │                      │
+          ▼                ▼                      │
+┌─────────────────────────────────────────────────┼───────────────┐
+│                      ClawBody                   │               │
+│  ┌─────────────────────────────────────────────┼────────────┐  │
+│  │         OpenAI Realtime API Handler         │            │  │
+│  │  • Speech recognition (Whisper)             │            │  │
+│  │  • Text-to-speech (voices)                 ─┘            │  │
+│  │  • Audio analysis → head wobble                          │  │
+│  └─────────────────────────────────────────────────────────┘  │
+│                           │                                     │
+│                           ▼                                     │
+│  ┌─────────────────────────────────────────────────────────┐  │
+│  │              OpenClaw Gateway Bridge                     │  │
+│  │  • AI responses from Clawson                            │  │
+│  │  • Full OpenClaw tool access                            │  │
+│  │  • Conversation memory & context                        │  │
+│  └─────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌──────────���──────────────────────────────────────────────────────┐
+│                    OpenClaw Gateway                              │
+│  • Web browsing  • Calendar  • Smart home  • Memory  • Tools    │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 📋 Prerequisites
+
+### Hardware
+- [Reachy Mini](https://www.pollen-robotics.com/reachy-mini/) robot (Wireless or Lite)
+
+### Software
+- Python 3.11+
+- [Reachy Mini SDK](https://github.com/pollen-robotics/reachy_mini) installed
+- [OpenClaw](https://github.com/openclaw/openclaw) gateway running
+- OpenAI API key with Realtime API access
+
+## 🚀 Installation
+
+### On the Reachy Mini Robot
+
+```bash
+# SSH into the robot
+ssh pollen@reachy-mini.local
+
+# Clone the repository
+git clone https://github.com/yourusername/clawbody.git
+cd clawbody
+
+# Install in the apps virtual environment
+/venvs/apps_venv/bin/pip install -e .
+```
+
+### Using pip (Development)
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/clawbody.git
+cd clawbody
+
+# Create virtual environment
+python -m venv .venv
+source .venv/bin/activate
+
+# Install
+pip install -e .
+```
+
+## ⚙️ Configuration
+
+1. Copy the example environment file:
+
+```bash
+cp .env.example .env
+```
+
+2. Edit `.env` with your configuration:
+
+```bash
+# Required
+OPENAI_API_KEY=sk-...your-key...
+
+# OpenClaw Gateway (required for AI responses)
+OPENCLAW_GATEWAY_URL=http://your-host-ip:18790
+OPENCLAW_TOKEN=your-gateway-token
+OPENCLAW_AGENT_ID=main
+
+# Optional - Customize voice
+OPENAI_VOICE=cedar
+```
+
+## 🎮 Usage
+
+### Console Mode
+
+```bash
+# Basic usage
+clawbody
+
+# With debug logging
+clawbody --debug
+
+# With specific robot
+clawbody --robot-name my-reachy
+```
+
+### Web UI Mode
+
+```bash
+# Launch Gradio interface
+clawbody --gradio
+```
+
+Then open http://localhost:7860 in your browser.
+
+### As a Reachy Mini App
+
+ClawBody registers as a Reachy Mini App, so you can launch it from the robot's dashboard after installation.
+
+### CLI Options
+
+| Option | Description |
+|--------|-------------|
+| `--debug` | Enable debug logging |
+| `--gradio` | Launch web UI instead of console mode |
+| `--robot-name NAME` | Specify robot name for connection |
+| `--gateway-url URL` | OpenClaw gateway URL |
+| `--no-camera` | Disable camera functionality |
+| `--no-openclaw` | Disable OpenClaw integration |
+
+## 🛠️ Robot Capabilities
+
+ClawBody gives Clawson these physical abilities:
+
+| Capability | Description |
+|------------|-------------|
+| **Look** | Move head to look in directions (left, right, up, down) |
+| **See** | Capture images through the robot's camera |
+| **Dance** | Perform expressive dance animations |
+| **Emotions** | Express emotions through movement (happy, curious, thinking, etc.) |
+| **Speak** | Voice output through the robot's speaker |
+| **Listen** | Hear through the robot's microphone |
+
+## 📄 License
+
+This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+ClawBody builds on:
+
+- [Pollen Robotics](https://www.pollen-robotics.com/) - Reachy Mini robot and SDK
+- [OpenClaw](https://github.com/openclaw/openclaw) - AI assistant framework (Clawson!)
+- [OpenAI](https://openai.com/) - Realtime API for voice I/O
+- [pollen-robotics/reachy_mini_conversation_app](https://huggingface.co/spaces/pollen-robotics/reachy_mini_conversation_app) - Movement and audio systems
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+- **This project**: [GitHub Issues](https://github.com/yourusername/clawbody/issues)
+- **OpenClaw Skills**: Submit ClawBody as a skill to [ClawHub](https://docs.openclaw.ai/tools/clawhub)
+- **Reachy Mini Apps**: Submit to [Pollen Robotics](https://github.com/pollen-robotics)

index.html

@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ClawBody - OpenClaw + Reachy Mini</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div class="container">
+        <header>
+            <div class="logo">🦞🤖</div>
+            <h1>ClawBody</h1>
+            <p class="tagline">Give your OpenClaw AI agent a physical robot body</p>
+        </header>
+
+        <main>
+            <section class="hero">
+                <div class="hero-content">
+                    <h2>Clawson, Embodied</h2>
+                    <p>
+                        ClawBody bridges <a href="https://github.com/openclaw/openclaw">OpenClaw</a> 
+                        with <a href="https://github.com/pollen-robotics/reachy_mini">Reachy Mini</a>,
+                        letting your AI assistant see, hear, speak, and move in the physical world.
+                    </p>
+                </div>
+            </section>
+
+            <section class="features">
+                <h3>Features</h3>
+                <div class="feature-grid">
+                    <div class="feature">
+                        <span class="feature-icon">🎤</span>
+                        <h4>Real-time Voice</h4>
+                        <p>OpenAI Realtime API for sub-second voice interaction</p>
+                    </div>
+                    <div class="feature">
+                        <span class="feature-icon">🧠</span>
+                        <h4>OpenClaw Intelligence</h4>
+                        <p>Full Clawson capabilities - tools, memory, personality</p>
+                    </div>
+                    <div class="feature">
+                        <span class="feature-icon">👀</span>
+                        <h4>Vision</h4>
+                        <p>See through the robot's camera and describe the world</p>
+                    </div>
+                    <div class="feature">
+                        <span class="feature-icon">💃</span>
+                        <h4>Expressive Movement</h4>
+                        <p>Natural head movements, emotions, dances, and wobble</p>
+                    </div>
+                </div>
+            </section>
+
+            <section class="architecture">
+                <h3>How It Works</h3>
+                <div class="arch-diagram">
+                    <div class="arch-flow">
+                        <div class="arch-box user">🗣️ You speak</div>
+                        <div class="arch-arrow">→</div>
+                        <div class="arch-box robot">🤖 Reachy Mini<br><small>microphone + camera</small></div>
+                        <div class="arch-arrow">→</div>
+                        <div class="arch-box clawbody">🦞 ClawBody<br><small>OpenAI Realtime</small></div>
+                        <div class="arch-arrow">→</div>
+                        <div class="arch-box openclaw">🧠 OpenClaw<br><small>Clawson responds</small></div>
+                    </div>
+                    <div class="arch-return">
+                        <div class="arch-arrow-return">← Robot speaks & moves ←</div>
+                    </div>
+                </div>
+            </section>
+
+            <section class="installation">
+                <h3>Quick Start</h3>
+                <div class="code-block">
+                    <pre><code># SSH into your Reachy Mini
+ssh pollen@reachy-mini.local
+
+# Clone and install
+git clone https://huggingface.co/spaces/YOUR_USERNAME/clawbody
+cd clawbody
+pip install -e .
+
+# Configure
+cp .env.example .env
+# Edit .env with your OpenAI key and OpenClaw gateway URL
+
+# Run
+clawbody</code></pre>
+                </div>
+            </section>
+
+            <section class="requirements">
+                <h3>Requirements</h3>
+                <ul>
+                    <li><strong>Reachy Mini</strong> robot (Wireless or Lite)</li>
+                    <li><strong>OpenClaw</strong> gateway running on your network</li>
+                    <li><strong>OpenAI API key</strong> with Realtime API access</li>
+                </ul>
+            </section>
+
+            <section class="links">
+                <h3>Resources</h3>
+                <div class="link-grid">
+                    <a href="https://github.com/openclaw/openclaw" class="link-card">
+                        <span>🦞</span>
+                        <span>OpenClaw</span>
+                    </a>
+                    <a href="https://github.com/pollen-robotics/reachy_mini" class="link-card">
+                        <span>🤖</span>
+                        <span>Reachy Mini SDK</span>
+                    </a>
+                    <a href="https://platform.openai.com/docs/guides/realtime" class="link-card">
+                        <span>🎙️</span>
+                        <span>OpenAI Realtime</span>
+                    </a>
+                </div>
+            </section>
+        </main>
+
+        <footer>
+            <p>
+                Made with 🦞 by <a href="https://github.com/yourusername">Tom</a>
+                · Apache 2.0 License
+            </p>
+        </footer>
+    </div>
+</body>
+</html>

openclaw-skill/SKILL.md

@@ -0,0 +1,97 @@
+# Reachy Mini Robot Body
+
+Give your OpenClaw agent a physical presence with Reachy Mini robot.
+
+## Description
+
+This skill enables OpenClaw to embody a Reachy Mini robot, allowing your AI assistant to:
+
+- **See**: View the world through the robot's camera
+- **Hear**: Listen to conversations via the robot's microphone  
+- **Speak**: Respond with natural voice through the robot's speaker
+- **Move**: Express emotions and reactions through expressive head movements
+
+Using OpenAI's Realtime API, the robot responds with sub-second latency for natural conversation flow.
+
+## Requirements
+
+### Hardware
+- [Reachy Mini](https://www.hf.co/reachy-mini/) robot (Wireless or Lite version)
+- The robot must be powered on and reachable on the network
+
+### Software
+- Python 3.11+
+- OpenAI API key with Realtime API access
+- OpenClaw gateway running (for extended capabilities)
+
+## Installation
+
+```bash
+# Install the package
+pip install reachy-mini-openclaw
+
+# Or from source
+git clone https://github.com/yourusername/reachy_mini_openclaw.git
+cd reachy_mini_openclaw
+pip install -e .
+```
+
+## Configuration
+
+Create a `.env` file with your OpenAI API key:
+
+```bash
+OPENAI_API_KEY=sk-your-key-here
+OPENCLAW_GATEWAY_URL=http://localhost:18789
+```
+
+## Usage
+
+### Console Mode
+```bash
+reachy-openclaw
+```
+
+### Web UI Mode
+```bash
+reachy-openclaw --gradio
+```
+
+### As Reachy Mini App
+Install from the robot's dashboard app store.
+
+## Features
+
+### Voice Conversation
+Real-time voice interaction using OpenAI's Realtime API for natural, low-latency conversation.
+
+### Expressive Movements
+The robot automatically:
+- Nods and moves while speaking (audio-driven wobble)
+- Looks toward speakers
+- Expresses emotions through head movements
+- Performs dances when appropriate
+
+### Vision
+Ask the robot to describe what it sees:
+> "What do you see in front of you?"
+
+### OpenClaw Integration
+Full access to OpenClaw's tool ecosystem:
+> "What's the weather like today?"
+> "Add a reminder for tomorrow"
+> "Turn on the living room lights"
+
+## Links
+
+- [GitHub Repository](https://github.com/yourusername/reachy_mini_openclaw)
+- [Reachy Mini SDK](https://github.com/pollen-robotics/reachy_mini)
+- [OpenClaw Documentation](https://docs.openclaw.ai)
+
+## Author
+
+Tom
+
+## License
+
+Apache 2.0

pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clawbody"
+version = "0.1.0"
+description = "ClawBody - Give your OpenClaw AI agent a physical robot body with Reachy Mini. Voice conversation powered by OpenAI Realtime API with expressive movements."
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.11"
+authors = [
+    {name = "Tom", email = "tom@example.com"}
+]
+keywords = [
+    "clawbody",
+    "reachy-mini",
+    "openclaw",
+    "clawson",
+    "robotics",
+    "ai-assistant",
+    "openai-realtime",
+    "voice-conversation",
+    "expressive-robot",
+    "embodied-ai"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Human Machine Interfaces",
+]
+dependencies = [
+    # OpenAI Realtime API
+    "openai>=1.50.0",
+    
+    # Audio streaming
+    "fastrtc>=0.0.17",
+    "numpy",
+    "scipy",
+    
+    # OpenClaw gateway client
+    "httpx>=0.27.0",
+    "httpx-sse>=0.4.0",
+    "websockets>=12.0",
+    
+    # Gradio UI
+    "gradio>=4.0.0",
+    
+    # Environment
+    "python-dotenv",
+]
+
+# Note: reachy-mini SDK must be installed separately from the robot or GitHub:
+# pip install git+https://github.com/pollen-robotics/reachy_mini.git
+# Or on the robot, it's pre-installed.
+
+[project.optional-dependencies]
+wireless = [
+    "pygobject",
+]
+vision = [
+    "opencv-python",
+    "ultralytics",
+]
+dev = [
+    "pytest",
+    "pytest-asyncio",
+    "ruff",
+    "mypy",
+]
+
+[project.scripts]
+clawbody = "reachy_mini_openclaw.main:main"
+
+[project.entry-points."reachy_mini_apps"]
+clawbody = "reachy_mini_openclaw.main:ClawBodyApp"
+
+[project.urls]
+Homepage = "https://github.com/yourusername/clawbody"
+Documentation = "https://github.com/yourusername/clawbody#readme"
+Repository = "https://github.com/yourusername/clawbody"
+Issues = "https://github.com/yourusername/clawbody/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true

src/reachy_mini_openclaw/__init__.py

@@ -0,0 +1,9 @@
+"""Reachy Mini OpenClaw - Give your OpenClaw AI agent a physical presence.
+
+This package combines OpenAI's Realtime API for responsive voice conversation
+with Reachy Mini's expressive robot movements, allowing your OpenClaw agent
+to see, hear, and speak through a physical robot body.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Tom"

src/reachy_mini_openclaw/audio/__init__.py

@@ -0,0 +1,5 @@
+"""Audio processing modules for Reachy Mini OpenClaw."""
+
+from reachy_mini_openclaw.audio.head_wobbler import HeadWobbler
+
+__all__ = ["HeadWobbler"]

src/reachy_mini_openclaw/audio/head_wobbler.py

@@ -0,0 +1,223 @@
+"""Audio-driven head movement for natural speech animation.
+
+This module analyzes audio output in real-time and generates subtle head
+movements that make the robot appear more expressive and alive while speaking.
+
+The wobble is generated based on:
+- Audio amplitude (volume) -> vertical movement
+- Frequency content -> horizontal sway
+- Speech rhythm -> timing of movements
+
+Design:
+- Runs in a separate thread to avoid blocking the main audio pipeline
+- Uses a circular buffer for smooth interpolation
+- Generates offsets that are added to the primary pose by MovementManager
+"""
+
+import base64
+import logging
+import threading
+import time
+from collections import deque
+from typing import Callable, Optional, Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+
+logger = logging.getLogger(__name__)
+
+# Type alias for speech offsets: (x, y, z, roll, pitch, yaw)
+SpeechOffsets = Tuple[float, float, float, float, float, float]
+
+
+class HeadWobbler:
+    """Generate audio-driven head movements for expressive speech.
+    
+    The wobbler analyzes incoming audio and produces subtle head movements
+    that are synchronized with speech patterns, making the robot appear
+    more natural and engaged during conversation.
+    
+    Example:
+        def apply_offsets(offsets):
+            movement_manager.set_speech_offsets(offsets)
+        
+        wobbler = HeadWobbler(set_speech_offsets=apply_offsets)
+        wobbler.start()
+        
+        # Feed audio as it's played
+        wobbler.feed(base64_audio_chunk)
+        
+        wobbler.stop()
+    """
+    
+    def __init__(
+        self,
+        set_speech_offsets: Callable[[SpeechOffsets], None],
+        sample_rate: int = 24000,
+        update_rate: float = 30.0,  # Hz
+    ):
+        """Initialize the head wobbler.
+        
+        Args:
+            set_speech_offsets: Callback to apply offsets to the movement system
+            sample_rate: Expected audio sample rate (Hz)
+            update_rate: How often to update offsets (Hz)
+        """
+        self.set_speech_offsets = set_speech_offsets
+        self.sample_rate = sample_rate
+        self.update_period = 1.0 / update_rate
+        
+        # Audio analysis parameters
+        self.amplitude_scale = 0.008  # Max displacement in meters
+        self.roll_scale = 0.15  # Max roll in radians
+        self.pitch_scale = 0.08  # Max pitch in radians
+        self.smoothing = 0.3  # Smoothing factor (0-1)
+        
+        # State
+        self._audio_buffer: deque[NDArray[np.float32]] = deque(maxlen=10)
+        self._buffer_lock = threading.Lock()
+        self._current_amplitude = 0.0
+        self._current_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+        
+        # Thread control
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._last_feed_time = 0.0
+        self._is_speaking = False
+        
+        # Decay parameters for smooth return to neutral
+        self._decay_rate = 3.0  # How fast to decay when not speaking
+        self._speech_timeout = 0.3  # Seconds of silence before decay starts
+        
+    def start(self) -> None:
+        """Start the wobbler thread."""
+        if self._thread is not None and self._thread.is_alive():
+            logger.warning("HeadWobbler already running")
+            return
+            
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+        logger.debug("HeadWobbler started")
+        
+    def stop(self) -> None:
+        """Stop the wobbler thread."""
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=1.0)
+            self._thread = None
+        
+        # Reset to neutral
+        self.set_speech_offsets((0.0, 0.0, 0.0, 0.0, 0.0, 0.0))
+        logger.debug("HeadWobbler stopped")
+        
+    def reset(self) -> None:
+        """Reset the wobbler state (call when speech ends or is interrupted)."""
+        with self._buffer_lock:
+            self._audio_buffer.clear()
+        self._current_amplitude = 0.0
+        self._is_speaking = False
+        self.set_speech_offsets((0.0, 0.0, 0.0, 0.0, 0.0, 0.0))
+        logger.debug("HeadWobbler reset")
+        
+    def feed(self, audio_b64: str) -> None:
+        """Feed audio data to the wobbler.
+        
+        Args:
+            audio_b64: Base64-encoded PCM audio (int16)
+        """
+        try:
+            audio_bytes = base64.b64decode(audio_b64)
+            audio_int16 = np.frombuffer(audio_bytes, dtype=np.int16)
+            audio_float = audio_int16.astype(np.float32) / 32768.0
+            
+            with self._buffer_lock:
+                self._audio_buffer.append(audio_float)
+                
+            self._last_feed_time = time.monotonic()
+            self._is_speaking = True
+            
+        except Exception as e:
+            logger.debug("Error feeding audio to wobbler: %s", e)
+            
+    def _compute_amplitude(self) -> float:
+        """Compute current audio amplitude from buffer."""
+        with self._buffer_lock:
+            if not self._audio_buffer:
+                return 0.0
+            
+            # Concatenate recent audio
+            audio = np.concatenate(list(self._audio_buffer))
+            
+        # RMS amplitude
+        rms = np.sqrt(np.mean(audio ** 2))
+        return min(1.0, rms * 3.0)  # Scale and clamp
+        
+    def _compute_offsets(self, amplitude: float, t: float) -> SpeechOffsets:
+        """Compute head offsets based on amplitude and time.
+        
+        Args:
+            amplitude: Current audio amplitude (0-1)
+            t: Current time for oscillation
+            
+        Returns:
+            Tuple of (x, y, z, roll, pitch, yaw) offsets
+        """
+        if amplitude < 0.01:
+            return (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+            
+        # Vertical bob based on amplitude
+        z_offset = amplitude * self.amplitude_scale * np.sin(t * 8.0)
+        
+        # Subtle roll sway
+        roll_offset = amplitude * self.roll_scale * np.sin(t * 3.0)
+        
+        # Pitch variation
+        pitch_offset = amplitude * self.pitch_scale * np.sin(t * 5.0 + 0.5)
+        
+        # Small yaw drift
+        yaw_offset = amplitude * 0.05 * np.sin(t * 2.0)
+        
+        return (0.0, 0.0, z_offset, roll_offset, pitch_offset, yaw_offset)
+        
+    def _run_loop(self) -> None:
+        """Main wobbler loop."""
+        start_time = time.monotonic()
+        
+        while not self._stop_event.is_set():
+            loop_start = time.monotonic()
+            t = loop_start - start_time
+            
+            # Check if we're still receiving audio
+            silence_duration = loop_start - self._last_feed_time
+            
+            if silence_duration > self._speech_timeout:
+                # Decay amplitude when not speaking
+                self._current_amplitude *= np.exp(-self._decay_rate * self.update_period)
+                self._is_speaking = False
+            else:
+                # Compute new amplitude with smoothing
+                raw_amplitude = self._compute_amplitude()
+                self._current_amplitude = (
+                    self.smoothing * raw_amplitude +
+                    (1 - self.smoothing) * self._current_amplitude
+                )
+            
+            # Compute and apply offsets
+            offsets = self._compute_offsets(self._current_amplitude, t)
+            
+            # Smooth transition between offsets
+            new_offsets = tuple(
+                self.smoothing * new + (1 - self.smoothing) * old
+                for new, old in zip(offsets, self._current_offsets)
+            )
+            self._current_offsets = new_offsets
+            
+            # Apply to movement system
+            self.set_speech_offsets(new_offsets)
+            
+            # Maintain update rate
+            elapsed = time.monotonic() - loop_start
+            sleep_time = max(0.0, self.update_period - elapsed)
+            if sleep_time > 0:
+                time.sleep(sleep_time)

src/reachy_mini_openclaw/config.py

@@ -0,0 +1,59 @@
+"""Configuration management for Reachy Mini OpenClaw.
+
+Handles environment variables and configuration settings for the application.
+"""
+
+import os
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional
+
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+_project_root = Path(__file__).parent.parent.parent
+load_dotenv(_project_root / ".env")
+
+
+@dataclass
+class Config:
+    """Application configuration loaded from environment variables."""
+    
+    # OpenAI Configuration
+    OPENAI_API_KEY: str = field(default_factory=lambda: os.getenv("OPENAI_API_KEY", ""))
+    OPENAI_MODEL: str = field(default_factory=lambda: os.getenv("OPENAI_MODEL", "gpt-4o-realtime-preview-2024-12-17"))
+    OPENAI_VOICE: str = field(default_factory=lambda: os.getenv("OPENAI_VOICE", "cedar"))
+    
+    # OpenClaw Gateway Configuration
+    OPENCLAW_GATEWAY_URL: str = field(default_factory=lambda: os.getenv("OPENCLAW_GATEWAY_URL", "http://localhost:18789"))
+    OPENCLAW_TOKEN: Optional[str] = field(default_factory=lambda: os.getenv("OPENCLAW_TOKEN"))
+    OPENCLAW_AGENT_ID: str = field(default_factory=lambda: os.getenv("OPENCLAW_AGENT_ID", "main"))
+    
+    # Robot Configuration
+    ROBOT_NAME: Optional[str] = field(default_factory=lambda: os.getenv("ROBOT_NAME"))
+    
+    # Feature Flags
+    ENABLE_OPENCLAW_TOOLS: bool = field(default_factory=lambda: os.getenv("ENABLE_OPENCLAW_TOOLS", "true").lower() == "true")
+    ENABLE_CAMERA: bool = field(default_factory=lambda: os.getenv("ENABLE_CAMERA", "true").lower() == "true")
+    ENABLE_FACE_TRACKING: bool = field(default_factory=lambda: os.getenv("ENABLE_FACE_TRACKING", "false").lower() == "true")
+    
+    # Custom Profile (for personality customization)
+    CUSTOM_PROFILE: Optional[str] = field(default_factory=lambda: os.getenv("REACHY_MINI_CUSTOM_PROFILE"))
+    
+    def validate(self) -> list[str]:
+        """Validate configuration and return list of errors."""
+        errors = []
+        if not self.OPENAI_API_KEY:
+            errors.append("OPENAI_API_KEY is required")
+        return errors
+
+
+# Global configuration instance
+config = Config()
+
+
+def set_custom_profile(profile: Optional[str]) -> None:
+    """Update the custom profile at runtime."""
+    global config
+    config.CUSTOM_PROFILE = profile
+    os.environ["REACHY_MINI_CUSTOM_PROFILE"] = profile or ""

src/reachy_mini_openclaw/gradio_app.py

@@ -0,0 +1,194 @@
+"""Gradio web UI for Reachy Mini OpenClaw.
+
+This module provides a web interface for:
+- Viewing conversation transcripts
+- Configuring the assistant personality
+- Monitoring robot status
+- Manual control options
+"""
+
+import os
+import logging
+from typing import Optional
+
+import gradio as gr
+
+logger = logging.getLogger(__name__)
+
+
+def launch_gradio(
+    gateway_url: str = "http://localhost:18789",
+    robot_name: Optional[str] = None,
+    enable_camera: bool = True,
+    enable_openclaw: bool = True,
+    share: bool = False,
+) -> None:
+    """Launch the Gradio web UI.
+    
+    Args:
+        gateway_url: OpenClaw gateway URL
+        robot_name: Robot name for connection
+        enable_camera: Whether to enable camera
+        enable_openclaw: Whether to enable OpenClaw
+        share: Whether to create a public URL
+    """
+    from reachy_mini_openclaw.prompts import get_available_profiles, save_custom_profile
+    from reachy_mini_openclaw.config import set_custom_profile, config
+    
+    # State
+    app_instance = None
+    
+    def start_conversation():
+        """Start the conversation."""
+        nonlocal app_instance
+        
+        from reachy_mini_openclaw.main import ReachyOpenClawCore
+        import asyncio
+        import threading
+        
+        if app_instance is not None:
+            return "Already running"
+        
+        try:
+            app_instance = ReachyOpenClawCore(
+                gateway_url=gateway_url,
+                robot_name=robot_name,
+                enable_camera=enable_camera,
+                enable_openclaw=enable_openclaw,
+            )
+            
+            # Run in background thread
+            def run_app():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    loop.run_until_complete(app_instance.run())
+                except Exception as e:
+                    logger.error("App error: %s", e)
+                finally:
+                    loop.close()
+            
+            thread = threading.Thread(target=run_app, daemon=True)
+            thread.start()
+            
+            return "Started successfully"
+        except Exception as e:
+            return f"Error: {e}"
+    
+    def stop_conversation():
+        """Stop the conversation."""
+        nonlocal app_instance
+        
+        if app_instance is None:
+            return "Not running"
+        
+        try:
+            app_instance.stop()
+            app_instance = None
+            return "Stopped"
+        except Exception as e:
+            return f"Error: {e}"
+    
+    def apply_profile(profile_name):
+        """Apply a personality profile."""
+        set_custom_profile(profile_name if profile_name else None)
+        return f"Applied profile: {profile_name or 'default'}"
+    
+    def save_profile(name, instructions):
+        """Save a new profile."""
+        if save_custom_profile(name, instructions):
+            return f"Saved profile: {name}"
+        return "Error saving profile"
+    
+    # Build UI
+    with gr.Blocks(title="Reachy Mini OpenClaw") as demo:
+        gr.Markdown("""
+        # 🤖 Reachy Mini OpenClaw
+        
+        Give your OpenClaw AI agent a physical presence with Reachy Mini.
+        Using OpenAI Realtime API for responsive voice conversation.
+        """)
+        
+        with gr.Tab("Conversation"):
+            with gr.Row():
+                start_btn = gr.Button("▶️ Start", variant="primary")
+                stop_btn = gr.Button("⏹️ Stop", variant="secondary")
+            
+            status_text = gr.Textbox(label="Status", interactive=False)
+            
+            transcript = gr.Chatbot(label="Conversation", height=400)
+            
+            start_btn.click(start_conversation, outputs=[status_text])
+            stop_btn.click(stop_conversation, outputs=[status_text])
+        
+        with gr.Tab("Personality"):
+            profiles = get_available_profiles()
+            profile_dropdown = gr.Dropdown(
+                choices=[""] + profiles,
+                label="Select Profile",
+                value=""
+            )
+            apply_btn = gr.Button("Apply Profile")
+            profile_status = gr.Textbox(label="Status", interactive=False)
+            
+            apply_btn.click(
+                apply_profile,
+                inputs=[profile_dropdown],
+                outputs=[profile_status]
+            )
+            
+            gr.Markdown("### Create New Profile")
+            new_name = gr.Textbox(label="Profile Name")
+            new_instructions = gr.Textbox(
+                label="Instructions",
+                lines=10,
+                placeholder="Enter the system prompt for this personality..."
+            )
+            save_btn = gr.Button("Save Profile")
+            save_status = gr.Textbox(label="Save Status", interactive=False)
+            
+            save_btn.click(
+                save_profile,
+                inputs=[new_name, new_instructions],
+                outputs=[save_status]
+            )
+        
+        with gr.Tab("Settings"):
+            gr.Markdown(f"""
+            ### Current Configuration
+            
+            - **OpenClaw Gateway**: {gateway_url}
+            - **OpenAI Model**: {config.OPENAI_MODEL}
+            - **Voice**: {config.OPENAI_VOICE}
+            - **Camera Enabled**: {enable_camera}
+            - **OpenClaw Enabled**: {enable_openclaw}
+            
+            Edit `.env` file to change these settings.
+            """)
+        
+        with gr.Tab("About"):
+            gr.Markdown("""
+            ## About Reachy Mini OpenClaw
+            
+            This application combines:
+            
+            - **OpenAI Realtime API** for ultra-low-latency voice conversation
+            - **OpenClaw Gateway** for extended AI capabilities (web, calendar, smart home, etc.)
+            - **Reachy Mini Robot** for physical embodiment with expressive movements
+            
+            ### Features
+            
+            - 🎤 Real-time voice conversation
+            - 👀 Camera-based vision
+            - 💃 Expressive robot movements
+            - 🔧 Tool integration via OpenClaw
+            - 🎭 Customizable personalities
+            
+            ### Links
+            
+            - [Reachy Mini SDK](https://github.com/pollen-robotics/reachy_mini)
+            - [OpenClaw](https://github.com/openclaw/openclaw)
+            - [OpenAI Realtime API](https://platform.openai.com/docs/guides/realtime)
+            """)
+    
+    demo.launch(share=share, server_name="0.0.0.0", server_port=7860)

src/reachy_mini_openclaw/main.py

@@ -0,0 +1,420 @@
+"""ClawBody - Give your OpenClaw AI agent a physical robot body.
+
+This module provides the main application that connects:
+- OpenAI Realtime API for voice I/O (speech recognition + TTS)
+- OpenClaw Gateway for AI intelligence (Clawson's brain)
+- Reachy Mini robot for physical embodiment
+
+Usage:
+    # Console mode (direct audio)
+    clawbody
+
+    # With Gradio UI
+    clawbody --gradio
+
+    # With debug logging
+    clawbody --debug
+"""
+
+import os
+import sys
+import time
+import asyncio
+import logging
+import argparse
+import threading
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+
+# Load environment from project root (override=True ensures .env takes precedence)
+_project_root = Path(__file__).parent.parent.parent
+load_dotenv(_project_root / ".env", override=True)
+
+logger = logging.getLogger(__name__)
+
+
+def setup_logging(debug: bool = False) -> None:
+    """Configure logging for the application.
+    
+    Args:
+        debug: Enable debug level logging
+    """
+    level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    
+    # Reduce noise from libraries
+    if not debug:
+        logging.getLogger("httpx").setLevel(logging.WARNING)
+        logging.getLogger("websockets").setLevel(logging.WARNING)
+        logging.getLogger("openai").setLevel(logging.WARNING)
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments.
+    
+    Returns:
+        Parsed arguments namespace
+    """
+    parser = argparse.ArgumentParser(
+        description="ClawBody - Give your OpenClaw AI agent a physical robot body",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Run in console mode
+    clawbody
+
+    # Run with Gradio web UI
+    clawbody --gradio
+
+    # Connect to specific robot
+    clawbody --robot-name my-reachy
+
+    # Use different OpenClaw gateway
+    clawbody --gateway-url http://192.168.1.100:18790
+        """
+    )
+    
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging"
+    )
+    parser.add_argument(
+        "--gradio",
+        action="store_true",
+        help="Launch Gradio web UI instead of console mode"
+    )
+    parser.add_argument(
+        "--robot-name",
+        type=str,
+        help="Robot name for connection (default: auto-discover)"
+    )
+    parser.add_argument(
+        "--gateway-url",
+        type=str,
+        default=os.getenv("OPENCLAW_GATEWAY_URL", "http://localhost:18789"),
+        help="OpenClaw gateway URL (from OPENCLAW_GATEWAY_URL env or default)"
+    )
+    parser.add_argument(
+        "--no-camera",
+        action="store_true",
+        help="Disable camera functionality"
+    )
+    parser.add_argument(
+        "--no-openclaw",
+        action="store_true",
+        help="Disable OpenClaw integration"
+    )
+    parser.add_argument(
+        "--profile",
+        type=str,
+        help="Custom personality profile to use"
+    )
+    
+    return parser.parse_args()
+
+
+class ClawBodyCore:
+    """ClawBody core application controller.
+    
+    This class orchestrates all components:
+    - Reachy Mini robot connection and movement control
+    - OpenAI Realtime API for voice I/O
+    - OpenClaw gateway bridge for AI intelligence
+    - Audio input/output loops
+    """
+    
+    def __init__(
+        self,
+        gateway_url: str = "http://localhost:18789",
+        robot_name: Optional[str] = None,
+        enable_camera: bool = True,
+        enable_openclaw: bool = True,
+        robot: Optional["ReachyMini"] = None,
+        external_stop_event: Optional[threading.Event] = None,
+    ):
+        """Initialize the application.
+        
+        Args:
+            gateway_url: OpenClaw gateway URL
+            robot_name: Optional robot name for connection
+            enable_camera: Whether to enable camera functionality
+            enable_openclaw: Whether to enable OpenClaw integration
+            robot: Optional pre-initialized robot (for app framework)
+            external_stop_event: Optional external stop event
+        """
+        from reachy_mini import ReachyMini
+        from reachy_mini_openclaw.config import config
+        from reachy_mini_openclaw.moves import MovementManager
+        from reachy_mini_openclaw.audio.head_wobbler import HeadWobbler
+        from reachy_mini_openclaw.openclaw_bridge import OpenClawBridge
+        from reachy_mini_openclaw.tools.core_tools import ToolDependencies
+        from reachy_mini_openclaw.openai_realtime import OpenAIRealtimeHandler
+        
+        self.gateway_url = gateway_url
+        self._external_stop_event = external_stop_event
+        self._owns_robot = robot is None
+        
+        # Validate configuration
+        errors = config.validate()
+        if errors:
+            for error in errors:
+                logger.error("Config error: %s", error)
+            sys.exit(1)
+        
+        # Connect to robot
+        if robot is not None:
+            self.robot = robot
+            logger.info("Using provided Reachy Mini instance")
+        else:
+            logger.info("Connecting to Reachy Mini...")
+            robot_kwargs = {}
+            if robot_name:
+                robot_kwargs["robot_name"] = robot_name
+                
+            try:
+                self.robot = ReachyMini(**robot_kwargs)
+            except TimeoutError as e:
+                logger.error("Connection timeout: %s", e)
+                logger.error("Check that the robot is powered on and reachable.")
+                sys.exit(1)
+            except Exception as e:
+                logger.error("Robot connection failed: %s", e)
+                sys.exit(1)
+                
+            logger.info("Connected to robot: %s", self.robot.client.get_status())
+        
+        # Initialize movement system
+        logger.info("Initializing movement system...")
+        self.movement_manager = MovementManager(current_robot=self.robot)
+        self.head_wobbler = HeadWobbler(
+            set_speech_offsets=self.movement_manager.set_speech_offsets
+        )
+        
+        # Initialize OpenClaw bridge
+        self.openclaw_bridge = None
+        if enable_openclaw:
+            logger.info("Initializing OpenClaw bridge...")
+            self.openclaw_bridge = OpenClawBridge(
+                gateway_url=gateway_url,
+                gateway_token=config.OPENCLAW_TOKEN,
+            )
+        
+        # Camera worker (optional)
+        self.camera_worker = None
+        if enable_camera:
+            # Camera worker would be initialized here if needed
+            # For now, we use the robot's built-in camera access
+            pass
+        
+        # Create tool dependencies
+        self.deps = ToolDependencies(
+            movement_manager=self.movement_manager,
+            head_wobbler=self.head_wobbler,
+            robot=self.robot,
+            camera_worker=self.camera_worker,
+            openclaw_bridge=self.openclaw_bridge,
+        )
+        
+        # Initialize OpenAI Realtime handler with OpenClaw bridge
+        self.handler = OpenAIRealtimeHandler(
+            deps=self.deps,
+            openclaw_bridge=self.openclaw_bridge,
+        )
+        
+        # State
+        self._stop_event = asyncio.Event()
+        self._tasks: list[asyncio.Task] = []
+        
+    def _should_stop(self) -> bool:
+        """Check if we should stop."""
+        if self._stop_event.is_set():
+            return True
+        if self._external_stop_event is not None and self._external_stop_event.is_set():
+            return True
+        return False
+        
+    async def record_loop(self) -> None:
+        """Read audio from robot microphone and send to handler."""
+        input_sr = self.robot.media.get_input_audio_samplerate()
+        logger.info("Recording at %d Hz", input_sr)
+        
+        while not self._should_stop():
+            audio_frame = self.robot.media.get_audio_sample()
+            if audio_frame is not None:
+                await self.handler.receive((input_sr, audio_frame))
+            await asyncio.sleep(0.01)
+            
+    async def play_loop(self) -> None:
+        """Play audio from handler through robot speakers."""
+        output_sr = self.robot.media.get_output_audio_samplerate()
+        logger.info("Playing at %d Hz", output_sr)
+        
+        while not self._should_stop():
+            output = await self.handler.emit()
+            if output is not None:
+                if isinstance(output, tuple):
+                    input_sr, audio_data = output
+                    
+                    # Convert to float32 and normalize (OpenAI sends int16)
+                    audio_data = audio_data.flatten().astype("float32") / 32768.0
+                    
+                    # Reduce volume to prevent distortion (0.5 = 50% volume)
+                    audio_data = audio_data * 0.5
+                    
+                    # Resample if needed
+                    if input_sr != output_sr:
+                        from scipy.signal import resample
+                        num_samples = int(len(audio_data) * output_sr / input_sr)
+                        audio_data = resample(audio_data, num_samples).astype("float32")
+                        
+                    self.robot.media.push_audio_sample(audio_data)
+                # else: it's an AdditionalOutputs (transcript) - handle in UI mode
+                
+            await asyncio.sleep(0.01)
+            
+    async def run(self) -> None:
+        """Run the main application loop."""
+        # Test OpenClaw connection
+        if self.openclaw_bridge is not None:
+            connected = await self.openclaw_bridge.connect()
+            if connected:
+                logger.info("OpenClaw gateway connected")
+            else:
+                logger.warning("OpenClaw gateway not available - some features disabled")
+        
+        # Start movement system
+        logger.info("Starting movement system...")
+        self.movement_manager.start()
+        self.head_wobbler.start()
+        
+        # Start audio
+        logger.info("Starting audio...")
+        self.robot.media.start_recording()
+        self.robot.media.start_playing()
+        time.sleep(1)  # Let pipelines initialize
+        
+        logger.info("Ready! Speak to me...")
+        
+        # Start OpenAI handler in background
+        handler_task = asyncio.create_task(self.handler.start_up(), name="openai-handler")
+        
+        # Start audio loops
+        self._tasks = [
+            handler_task,
+            asyncio.create_task(self.record_loop(), name="record-loop"),
+            asyncio.create_task(self.play_loop(), name="play-loop"),
+        ]
+        
+        try:
+            await asyncio.gather(*self._tasks)
+        except asyncio.CancelledError:
+            logger.info("Tasks cancelled")
+            
+    def stop(self) -> None:
+        """Stop everything."""
+        logger.info("Stopping...")
+        self._stop_event.set()
+        
+        # Cancel tasks
+        for task in self._tasks:
+            if not task.done():
+                task.cancel()
+                
+        # Stop movement system
+        self.head_wobbler.stop()
+        self.movement_manager.stop()
+        
+        # Close resources if we own them
+        if self._owns_robot:
+            try:
+                self.robot.media.close()
+            except Exception as e:
+                logger.debug("Media close: %s", e)
+            self.robot.client.disconnect()
+            
+        logger.info("Stopped")
+
+
+class ClawBodyApp:
+    """ClawBody - Reachy Mini Apps entry point.
+    
+    This class allows ClawBody to be installed and run from
+    the Reachy Mini dashboard as a Reachy Mini App.
+    """
+    
+    # No custom settings UI
+    custom_app_url: Optional[str] = None
+    
+    def run(self, reachy_mini, stop_event: threading.Event) -> None:
+        """Run ClawBody as a Reachy Mini App.
+        
+        Args:
+            reachy_mini: Pre-initialized ReachyMini instance
+            stop_event: Threading event to signal stop
+        """
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        gateway_url = os.getenv("OPENCLAW_GATEWAY_URL", "http://localhost:18789")
+        
+        app = ClawBodyCore(
+            gateway_url=gateway_url,
+            robot=reachy_mini,
+            external_stop_event=stop_event,
+        )
+        
+        try:
+            loop.run_until_complete(app.run())
+        except Exception as e:
+            logger.error("Error running app: %s", e)
+        finally:
+            app.stop()
+            loop.close()
+
+
+def main() -> None:
+    """Main entry point."""
+    args = parse_args()
+    setup_logging(args.debug)
+    
+    # Set custom profile if specified
+    if args.profile:
+        from reachy_mini_openclaw.config import set_custom_profile
+        set_custom_profile(args.profile)
+    
+    if args.gradio:
+        # Launch Gradio UI
+        logger.info("Starting Gradio UI...")
+        from reachy_mini_openclaw.gradio_app import launch_gradio
+        launch_gradio(
+            gateway_url=args.gateway_url,
+            robot_name=args.robot_name,
+            enable_camera=not args.no_camera,
+            enable_openclaw=not args.no_openclaw,
+        )
+    else:
+        # Console mode
+        app = ClawBodyCore(
+            gateway_url=args.gateway_url,
+            robot_name=args.robot_name,
+            enable_camera=not args.no_camera,
+            enable_openclaw=not args.no_openclaw,
+        )
+        
+        try:
+            asyncio.run(app.run())
+        except KeyboardInterrupt:
+            logger.info("Interrupted")
+        finally:
+            app.stop()
+
+
+if __name__ == "__main__":
+    main()

src/reachy_mini_openclaw/moves.py

@@ -0,0 +1,551 @@
+"""Movement system for expressive robot control.
+
+This module provides a 100Hz control loop for managing robot movements,
+combining sequential primary moves (dances, emotions, head movements) with
+additive secondary moves (speech wobble, face tracking).
+
+Architecture:
+- Primary moves are queued and executed sequentially
+- Secondary moves are additive offsets applied on top
+- Single control point via set_target at 100Hz
+- Automatic breathing animation when idle
+
+Based on the movement systems from:
+- pollen-robotics/reachy_mini_conversation_app
+- eoai-dev/moltbot_body
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass
+from queue import Empty, Queue
+from typing import Any, Dict, Optional, Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+from reachy_mini import ReachyMini
+from reachy_mini.motion.move import Move
+from reachy_mini.utils import create_head_pose
+from reachy_mini.utils.interpolation import compose_world_offset, linear_pose_interpolation
+
+logger = logging.getLogger(__name__)
+
+# Configuration
+CONTROL_LOOP_FREQUENCY_HZ = 100.0
+
+# Type definitions
+FullBodyPose = Tuple[NDArray[np.float32], Tuple[float, float], float]
+SpeechOffsets = Tuple[float, float, float, float, float, float]
+
+
+class BreathingMove(Move):
+    """Continuous breathing animation for idle state."""
+    
+    def __init__(
+        self,
+        interpolation_start_pose: NDArray[np.float32],
+        interpolation_start_antennas: Tuple[float, float],
+        interpolation_duration: float = 1.0,
+    ):
+        """Initialize breathing move.
+        
+        Args:
+            interpolation_start_pose: Current head pose to interpolate from
+            interpolation_start_antennas: Current antenna positions
+            interpolation_duration: Time to blend to neutral (seconds)
+        """
+        self.interpolation_start_pose = interpolation_start_pose
+        self.interpolation_start_antennas = np.array(interpolation_start_antennas)
+        self.interpolation_duration = interpolation_duration
+        
+        # Target neutral pose
+        self.neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+        self.neutral_antennas = np.array([0.0, 0.0])
+        
+        # Breathing parameters
+        self.breathing_z_amplitude = 0.005  # 5mm gentle movement
+        self.breathing_frequency = 0.1  # Hz
+        self.antenna_sway_amplitude = np.deg2rad(15)  # degrees
+        self.antenna_frequency = 0.5  # Hz
+        
+    @property
+    def duration(self) -> float:
+        """Duration of the move (infinite for breathing)."""
+        return float("inf")
+        
+    def evaluate(self, t: float) -> tuple:
+        """Evaluate the breathing pose at time t."""
+        if t < self.interpolation_duration:
+            # Interpolate to neutral
+            alpha = t / self.interpolation_duration
+            head_pose = linear_pose_interpolation(
+                self.interpolation_start_pose, 
+                self.neutral_head_pose, 
+                alpha
+            )
+            antennas = (1 - alpha) * self.interpolation_start_antennas + alpha * self.neutral_antennas
+            antennas = antennas.astype(np.float64)
+        else:
+            # Breathing pattern
+            breathing_t = t - self.interpolation_duration
+            
+            z_offset = self.breathing_z_amplitude * np.sin(
+                2 * np.pi * self.breathing_frequency * breathing_t
+            )
+            head_pose = create_head_pose(
+                x=0, y=0, z=z_offset, 
+                roll=0, pitch=0, yaw=0, 
+                degrees=True, mm=False
+            )
+            
+            antenna_sway = self.antenna_sway_amplitude * np.sin(
+                2 * np.pi * self.antenna_frequency * breathing_t
+            )
+            antennas = np.array([antenna_sway, -antenna_sway], dtype=np.float64)
+            
+        return (head_pose, antennas, 0.0)
+
+
+class HeadLookMove(Move):
+    """Move to look in a specific direction."""
+    
+    DIRECTIONS = {
+        "left": (0, 0, 0, 0, 0, 30),      # yaw left
+        "right": (0, 0, 0, 0, 0, -30),    # yaw right
+        "up": (0, 0, 10, 0, 15, 0),       # pitch up, z up
+        "down": (0, 0, -5, 0, -15, 0),    # pitch down, z down
+        "front": (0, 0, 0, 0, 0, 0),      # neutral
+    }
+    
+    def __init__(
+        self,
+        direction: str,
+        start_pose: NDArray[np.float32],
+        start_antennas: Tuple[float, float],
+        duration: float = 1.0,
+    ):
+        """Initialize head look move.
+        
+        Args:
+            direction: One of 'left', 'right', 'up', 'down', 'front'
+            start_pose: Current head pose
+            start_antennas: Current antenna positions
+            duration: Move duration in seconds
+        """
+        self.direction = direction
+        self.start_pose = start_pose
+        self.start_antennas = np.array(start_antennas)
+        self._duration = duration
+        
+        # Get target pose from direction
+        params = self.DIRECTIONS.get(direction, self.DIRECTIONS["front"])
+        self.target_pose = create_head_pose(
+            x=params[0], y=params[1], z=params[2],
+            roll=params[3], pitch=params[4], yaw=params[5],
+            degrees=True, mm=True
+        )
+        self.target_antennas = np.array([0.0, 0.0])
+        
+    @property
+    def duration(self) -> float:
+        return self._duration
+        
+    def evaluate(self, t: float) -> tuple:
+        """Evaluate pose at time t."""
+        alpha = min(1.0, t / self._duration)
+        # Smooth easing
+        alpha = alpha * alpha * (3 - 2 * alpha)
+        
+        head_pose = linear_pose_interpolation(
+            self.start_pose,
+            self.target_pose,
+            alpha
+        )
+        antennas = (1 - alpha) * self.start_antennas + alpha * self.target_antennas
+        
+        return (head_pose, antennas.astype(np.float64), 0.0)
+
+
+def combine_full_body(primary: FullBodyPose, secondary: FullBodyPose) -> FullBodyPose:
+    """Combine primary pose with secondary offsets."""
+    primary_head, primary_ant, primary_yaw = primary
+    secondary_head, secondary_ant, secondary_yaw = secondary
+    
+    combined_head = compose_world_offset(primary_head, secondary_head, reorthonormalize=True)
+    combined_ant = (
+        primary_ant[0] + secondary_ant[0],
+        primary_ant[1] + secondary_ant[1],
+    )
+    combined_yaw = primary_yaw + secondary_yaw
+    
+    return (combined_head, combined_ant, combined_yaw)
+
+
+def clone_pose(pose: FullBodyPose) -> FullBodyPose:
+    """Deep copy a full body pose."""
+    head, ant, yaw = pose
+    return (head.copy(), (float(ant[0]), float(ant[1])), float(yaw))
+
+
+@dataclass
+class MovementState:
+    """State for the movement system."""
+    current_move: Optional[Move] = None
+    move_start_time: Optional[float] = None
+    last_activity_time: float = 0.0
+    speech_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    face_tracking_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    last_primary_pose: Optional[FullBodyPose] = None
+    
+    def update_activity(self) -> None:
+        self.last_activity_time = time.monotonic()
+
+
+class MovementManager:
+    """Coordinate robot movements at 100Hz.
+    
+    This class manages:
+    - Sequential primary moves (dances, emotions, head movements)
+    - Additive secondary offsets (speech wobble, face tracking)
+    - Automatic idle breathing animation
+    - Thread-safe communication with other components
+    
+    Example:
+        manager = MovementManager(robot)
+        manager.start()
+        
+        # Queue a head movement
+        manager.queue_move(HeadLookMove("left", ...))
+        
+        # Set speech offsets (called by HeadWobbler)
+        manager.set_speech_offsets((0, 0, 0.01, 0.1, 0, 0))
+        
+        manager.stop()
+    """
+    
+    def __init__(
+        self,
+        current_robot: ReachyMini,
+        camera_worker: Any = None,
+    ):
+        """Initialize movement manager.
+        
+        Args:
+            current_robot: Connected ReachyMini instance
+            camera_worker: Optional camera worker for face tracking
+        """
+        self.current_robot = current_robot
+        self.camera_worker = camera_worker
+        
+        self._now = time.monotonic
+        self.state = MovementState()
+        self.state.last_activity_time = self._now()
+        
+        # Initialize neutral pose
+        neutral = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+        self.state.last_primary_pose = (neutral, (0.0, 0.0), 0.0)
+        
+        # Move queue
+        self.move_queue: deque[Move] = deque()
+        
+        # Configuration
+        self.idle_inactivity_delay = 0.3  # seconds before breathing starts
+        self.target_frequency = CONTROL_LOOP_FREQUENCY_HZ
+        self.target_period = 1.0 / self.target_frequency
+        
+        # Thread state
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._is_listening = False
+        self._breathing_active = False
+        
+        # Last commanded pose for smooth transitions
+        self._last_commanded_pose = clone_pose(self.state.last_primary_pose)
+        self._listening_antennas = self._last_commanded_pose[1]
+        self._antenna_unfreeze_blend = 1.0
+        self._antenna_blend_duration = 0.4
+        
+        # Cross-thread communication
+        self._command_queue: Queue[Tuple[str, Any]] = Queue()
+        
+        # Speech offsets (thread-safe)
+        self._speech_lock = threading.Lock()
+        self._pending_speech_offsets: SpeechOffsets = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+        self._speech_dirty = False
+        
+        # Shared state lock
+        self._shared_lock = threading.Lock()
+        self._shared_last_activity = self.state.last_activity_time
+        self._shared_is_listening = False
+        
+    def queue_move(self, move: Move) -> None:
+        """Queue a primary move. Thread-safe."""
+        self._command_queue.put(("queue_move", move))
+        
+    def clear_move_queue(self) -> None:
+        """Clear all queued moves. Thread-safe."""
+        self._command_queue.put(("clear_queue", None))
+        
+    def set_speech_offsets(self, offsets: SpeechOffsets) -> None:
+        """Update speech-driven offsets. Thread-safe."""
+        with self._speech_lock:
+            self._pending_speech_offsets = offsets
+            self._speech_dirty = True
+            
+    def set_listening(self, listening: bool) -> None:
+        """Set listening state (freezes antennas). Thread-safe."""
+        self._command_queue.put(("set_listening", listening))
+        
+    def is_idle(self) -> bool:
+        """Check if robot has been idle. Thread-safe."""
+        with self._shared_lock:
+            if self._shared_is_listening:
+                return False
+            return self._now() - self._shared_last_activity >= self.idle_inactivity_delay
+            
+    def _poll_signals(self, current_time: float) -> None:
+        """Process queued commands and pending offsets."""
+        # Apply speech offsets
+        with self._speech_lock:
+            if self._speech_dirty:
+                self.state.speech_offsets = self._pending_speech_offsets
+                self._speech_dirty = False
+                self.state.update_activity()
+                
+        # Process commands
+        while True:
+            try:
+                cmd, payload = self._command_queue.get_nowait()
+            except Empty:
+                break
+            self._handle_command(cmd, payload, current_time)
+            
+    def _handle_command(self, cmd: str, payload: Any, current_time: float) -> None:
+        """Handle a single command."""
+        if cmd == "queue_move":
+            if isinstance(payload, Move):
+                self.move_queue.append(payload)
+                self.state.update_activity()
+                logger.debug("Queued move, queue size: %d", len(self.move_queue))
+        elif cmd == "clear_queue":
+            self.move_queue.clear()
+            self.state.current_move = None
+            self.state.move_start_time = None
+            self._breathing_active = False
+            logger.info("Cleared move queue")
+        elif cmd == "set_listening":
+            desired = bool(payload)
+            if self._is_listening != desired:
+                self._is_listening = desired
+                if desired:
+                    self._listening_antennas = self._last_commanded_pose[1]
+                    self._antenna_unfreeze_blend = 0.0
+                else:
+                    self._antenna_unfreeze_blend = 0.0
+                self.state.update_activity()
+                
+    def _manage_move_queue(self, current_time: float) -> None:
+        """Advance the move queue."""
+        # Check if current move is done
+        if self.state.current_move is not None and self.state.move_start_time is not None:
+            elapsed = current_time - self.state.move_start_time
+            if elapsed >= self.state.current_move.duration:
+                self.state.current_move = None
+                self.state.move_start_time = None
+                
+        # Start next move if available
+        if self.state.current_move is None and self.move_queue:
+            self.state.current_move = self.move_queue.popleft()
+            self.state.move_start_time = current_time
+            self._breathing_active = isinstance(self.state.current_move, BreathingMove)
+            logger.debug("Starting move with duration: %s", self.state.current_move.duration)
+            
+    def _manage_breathing(self, current_time: float) -> None:
+        """Start breathing when idle."""
+        if (
+            self.state.current_move is None
+            and not self.move_queue
+            and not self._is_listening
+            and not self._breathing_active
+        ):
+            idle_for = current_time - self.state.last_activity_time
+            if idle_for >= self.idle_inactivity_delay:
+                try:
+                    _, current_ant = self.current_robot.get_current_joint_positions()
+                    current_head = self.current_robot.get_current_head_pose()
+                    
+                    breathing = BreathingMove(
+                        interpolation_start_pose=current_head,
+                        interpolation_start_antennas=current_ant,
+                        interpolation_duration=1.0,
+                    )
+                    self.move_queue.append(breathing)
+                    self._breathing_active = True
+                    self.state.update_activity()
+                    logger.debug("Started breathing after %.1fs idle", idle_for)
+                except Exception as e:
+                    logger.error("Failed to start breathing: %s", e)
+                    
+        # Stop breathing if new moves queued
+        if isinstance(self.state.current_move, BreathingMove) and self.move_queue:
+            self.state.current_move = None
+            self.state.move_start_time = None
+            self._breathing_active = False
+            
+    def _get_primary_pose(self, current_time: float) -> FullBodyPose:
+        """Get current primary pose from move or last pose."""
+        if self.state.current_move is not None and self.state.move_start_time is not None:
+            t = current_time - self.state.move_start_time
+            head, antennas, body_yaw = self.state.current_move.evaluate(t)
+            
+            if head is None:
+                head = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+            if antennas is None:
+                antennas = np.array([0.0, 0.0])
+            if body_yaw is None:
+                body_yaw = 0.0
+                
+            pose = (head.copy(), (float(antennas[0]), float(antennas[1])), float(body_yaw))
+            self.state.last_primary_pose = clone_pose(pose)
+            return pose
+            
+        if self.state.last_primary_pose is not None:
+            return clone_pose(self.state.last_primary_pose)
+            
+        neutral = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+        return (neutral, (0.0, 0.0), 0.0)
+        
+    def _get_secondary_pose(self) -> FullBodyPose:
+        """Get secondary offsets."""
+        offsets = [
+            self.state.speech_offsets[i] + self.state.face_tracking_offsets[i]
+            for i in range(6)
+        ]
+        
+        secondary_head = create_head_pose(
+            x=offsets[0], y=offsets[1], z=offsets[2],
+            roll=offsets[3], pitch=offsets[4], yaw=offsets[5],
+            degrees=False, mm=False
+        )
+        return (secondary_head, (0.0, 0.0), 0.0)
+        
+    def _compose_pose(self, current_time: float) -> FullBodyPose:
+        """Compose final pose from primary and secondary."""
+        primary = self._get_primary_pose(current_time)
+        secondary = self._get_secondary_pose()
+        return combine_full_body(primary, secondary)
+        
+    def _blend_antennas(self, target: Tuple[float, float]) -> Tuple[float, float]:
+        """Blend antennas with listening freeze state."""
+        if self._is_listening:
+            return self._listening_antennas
+            
+        # Blend back from freeze
+        blend = min(1.0, self._antenna_unfreeze_blend + self.target_period / self._antenna_blend_duration)
+        self._antenna_unfreeze_blend = blend
+        
+        return (
+            self._listening_antennas[0] * (1 - blend) + target[0] * blend,
+            self._listening_antennas[1] * (1 - blend) + target[1] * blend,
+        )
+        
+    def _issue_command(self, head: NDArray, antennas: Tuple[float, float], body_yaw: float) -> None:
+        """Send command to robot."""
+        try:
+            self.current_robot.set_target(head=head, antennas=antennas, body_yaw=body_yaw)
+            self._last_commanded_pose = (head.copy(), antennas, body_yaw)
+        except Exception as e:
+            logger.debug("set_target failed: %s", e)
+            
+    def _publish_shared_state(self) -> None:
+        """Update shared state for external queries."""
+        with self._shared_lock:
+            self._shared_last_activity = self.state.last_activity_time
+            self._shared_is_listening = self._is_listening
+            
+    def start(self) -> None:
+        """Start the control loop thread."""
+        if self._thread is not None and self._thread.is_alive():
+            logger.warning("MovementManager already running")
+            return
+            
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+        logger.info("MovementManager started")
+        
+    def stop(self) -> None:
+        """Stop the control loop and reset to neutral."""
+        if self._thread is None or not self._thread.is_alive():
+            return
+            
+        logger.info("Stopping MovementManager...")
+        self.clear_move_queue()
+        
+        self._stop_event.set()
+        self._thread.join(timeout=2.0)
+        self._thread = None
+        
+        # Reset to neutral
+        try:
+            neutral = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+            self.current_robot.goto_target(
+                head=neutral,
+                antennas=[0.0, 0.0],
+                duration=2.0,
+                body_yaw=0.0,
+            )
+            logger.info("Reset to neutral position")
+        except Exception as e:
+            logger.error("Failed to reset: %s", e)
+            
+    def _run_loop(self) -> None:
+        """Main control loop at 100Hz."""
+        logger.debug("Starting 100Hz control loop")
+        
+        while not self._stop_event.is_set():
+            loop_start = self._now()
+            
+            # Process signals
+            self._poll_signals(loop_start)
+            
+            # Manage moves
+            self._manage_move_queue(loop_start)
+            self._manage_breathing(loop_start)
+            
+            # Compose pose
+            head, antennas, body_yaw = self._compose_pose(loop_start)
+            
+            # Blend antennas for listening
+            antennas = self._blend_antennas(antennas)
+            
+            # Send to robot
+            self._issue_command(head, antennas, body_yaw)
+            
+            # Update shared state
+            self._publish_shared_state()
+            
+            # Maintain timing
+            elapsed = self._now() - loop_start
+            sleep_time = max(0.0, self.target_period - elapsed)
+            if sleep_time > 0:
+                time.sleep(sleep_time)
+                
+        logger.debug("Control loop stopped")
+        
+    def get_status(self) -> Dict[str, Any]:
+        """Get current status for debugging."""
+        return {
+            "queue_size": len(self.move_queue),
+            "is_listening": self._is_listening,
+            "breathing_active": self._breathing_active,
+            "last_commanded_pose": {
+                "head": self._last_commanded_pose[0].tolist(),
+                "antennas": self._last_commanded_pose[1],
+                "body_yaw": self._last_commanded_pose[2],
+            },
+        }

src/reachy_mini_openclaw/openai_realtime.py

@@ -0,0 +1,428 @@
+"""ClawBody - OpenAI Realtime API handler for voice I/O with OpenClaw intelligence.
+
+This module implements ClawBody's hybrid voice conversation system:
+- OpenAI Realtime API handles speech recognition and text-to-speech
+- OpenClaw (Clawson) provides the AI intelligence and responses
+
+Architecture:
+    User speaks -> OpenAI Realtime (transcription) -> OpenClaw (AI response)
+                                                   -> OpenAI Realtime (TTS) -> Robot speaks
+
+This gives ClawBody the best of both worlds:
+- Low-latency voice activity detection and speech recognition from OpenAI
+- Full OpenClaw/Clawson capabilities (tools, memory, personality) for responses
+"""
+
+import json
+import base64
+import random
+import asyncio
+import logging
+from typing import Any, Final, Literal, Optional, Tuple
+from datetime import datetime
+
+import numpy as np
+from numpy.typing import NDArray
+from openai import AsyncOpenAI
+from fastrtc import AdditionalOutputs, AsyncStreamHandler, wait_for_item
+from scipy.signal import resample
+from websockets.exceptions import ConnectionClosedError
+
+from reachy_mini_openclaw.config import config
+from reachy_mini_openclaw.prompts import get_session_voice
+from reachy_mini_openclaw.tools.core_tools import ToolDependencies, get_tool_specs, dispatch_tool_call
+from reachy_mini_openclaw.openclaw_bridge import OpenClawBridge
+
+logger = logging.getLogger(__name__)
+
+# OpenAI Realtime API audio format
+OPENAI_SAMPLE_RATE: Final[Literal[24000]] = 24000
+
+# System context for OpenClaw - tells it about its robot body
+ROBOT_SYSTEM_CONTEXT = """You are Clawson, the OpenClaw AI assistant, speaking through a Reachy Mini robot body.
+
+Your robot capabilities:
+- You can see through a camera (when the user asks you to look at something)
+- You can move your head expressively (look left/right/up/down, show emotions)
+- You can dance to express joy
+- You speak through a speaker
+
+Guidelines:
+- Keep responses concise and conversational (you're speaking, not typing)
+- Be warm, helpful, and occasionally witty - you're a friendly space lobster 🦞
+- Reference your robot body naturally ("let me look", "I can see...")
+- When you want to do something physical, just describe it naturally and I'll make it happen
+
+You ARE Clawson - not "an assistant" - speak as yourself."""
+
+
+class OpenAIRealtimeHandler(AsyncStreamHandler):
+    """Handler for OpenAI Realtime API voice I/O with OpenClaw backend.
+    
+    This handler:
+    - Receives audio from robot microphone
+    - Sends to OpenAI for speech recognition
+    - Routes transcripts to OpenClaw for AI response
+    - Uses OpenAI TTS to speak OpenClaw's response
+    - Handles robot movement tool calls locally
+    """
+    
+    def __init__(
+        self,
+        deps: ToolDependencies,
+        openclaw_bridge: Optional[OpenClawBridge] = None,
+        gradio_mode: bool = False,
+    ):
+        """Initialize the handler.
+        
+        Args:
+            deps: Tool dependencies for robot control
+            openclaw_bridge: Bridge to OpenClaw gateway
+            gradio_mode: Whether running with Gradio UI
+        """
+        super().__init__(
+            expected_layout="mono",
+            output_sample_rate=OPENAI_SAMPLE_RATE,
+            input_sample_rate=OPENAI_SAMPLE_RATE,
+        )
+        
+        self.deps = deps
+        self.openclaw_bridge = openclaw_bridge
+        self.gradio_mode = gradio_mode
+        
+        # OpenAI connection
+        self.client: Optional[AsyncOpenAI] = None
+        self.connection: Any = None
+        
+        # Output queue
+        self.output_queue: asyncio.Queue[Tuple[int, NDArray[np.int16]] | AdditionalOutputs] = asyncio.Queue()
+        
+        # State tracking
+        self.last_activity_time = 0.0
+        self.start_time = 0.0
+        self._processing_response = False
+        
+        # Pending transcript for OpenClaw
+        self._pending_transcript: Optional[str] = None
+        self._pending_image: Optional[str] = None
+        
+        # Lifecycle flags
+        self._shutdown_requested = False
+        self._connected_event = asyncio.Event()
+        
+    def copy(self) -> "OpenAIRealtimeHandler":
+        """Create a copy of the handler (required by fastrtc)."""
+        return OpenAIRealtimeHandler(self.deps, self.openclaw_bridge, self.gradio_mode)
+        
+    async def start_up(self) -> None:
+        """Start the handler and connect to OpenAI."""
+        api_key = config.OPENAI_API_KEY
+        if not api_key:
+            logger.error("OPENAI_API_KEY not configured")
+            raise ValueError("OPENAI_API_KEY required")
+            
+        self.client = AsyncOpenAI(api_key=api_key)
+        self.start_time = asyncio.get_event_loop().time()
+        self.last_activity_time = self.start_time
+        
+        max_attempts = 3
+        for attempt in range(1, max_attempts + 1):
+            try:
+                await self._run_session()
+                return
+            except ConnectionClosedError as e:
+                logger.warning("WebSocket closed unexpectedly (attempt %d/%d): %s", 
+                             attempt, max_attempts, e)
+                if attempt < max_attempts:
+                    delay = (2 ** (attempt - 1)) + random.uniform(0, 0.5)
+                    logger.info("Retrying in %.1f seconds...", delay)
+                    await asyncio.sleep(delay)
+                    continue
+                raise
+            finally:
+                self.connection = None
+                try:
+                    self._connected_event.clear()
+                except Exception:
+                    pass
+                    
+    async def _run_session(self) -> None:
+        """Run a single OpenAI Realtime session."""
+        model = config.OPENAI_MODEL
+        logger.info("Connecting to OpenAI Realtime API with model: %s", model)
+        
+        async with self.client.beta.realtime.connect(model=model) as conn:
+            # Configure session for voice I/O only (no auto-response)
+            # We'll manually trigger responses after getting OpenClaw's text
+            await conn.session.update(
+                session={
+                    "modalities": ["text", "audio"],
+                    "instructions": "You are a text-to-speech system. Read the provided text naturally and expressively. Do not add anything - just speak what you're given.",
+                    "voice": get_session_voice(),
+                    "input_audio_format": "pcm16",
+                    "output_audio_format": "pcm16",
+                    "input_audio_transcription": {
+                        "model": "whisper-1",
+                    },
+                    "turn_detection": {
+                        "type": "server_vad",
+                        "threshold": 0.5,
+                        "prefix_padding_ms": 300,
+                        "silence_duration_ms": 500,
+                    },
+                    "tools": get_tool_specs(),  # Robot movement tools
+                    "tool_choice": "auto",
+                },
+            )
+            logger.info("OpenAI Realtime session configured (hybrid mode)")
+            
+            self.connection = conn
+            self._connected_event.set()
+            
+            # Process events
+            async for event in conn:
+                await self._handle_event(event)
+                
+    async def _handle_event(self, event: Any) -> None:
+        """Handle an event from the OpenAI Realtime API."""
+        event_type = event.type
+        logger.debug("Event: %s", event_type)
+        
+        # Speech detection
+        if event_type == "input_audio_buffer.speech_started":
+            # User started speaking - clear any pending output
+            while not self.output_queue.empty():
+                try:
+                    self.output_queue.get_nowait()
+                except asyncio.QueueEmpty:
+                    break
+            if self.deps.head_wobbler is not None:
+                self.deps.head_wobbler.reset()
+            self.deps.movement_manager.set_listening(True)
+            logger.info("User speech started")
+            
+        if event_type == "input_audio_buffer.speech_stopped":
+            self.deps.movement_manager.set_listening(False)
+            logger.info("User speech stopped")
+            
+        # Transcription completed - this is when we send to OpenClaw
+        if event_type == "conversation.item.input_audio_transcription.completed":
+            transcript = event.transcript
+            if transcript and transcript.strip():
+                logger.info("User said: %s", transcript)
+                await self.output_queue.put(
+                    AdditionalOutputs({"role": "user", "content": transcript})
+                )
+                # Process through OpenClaw
+                await self._process_with_openclaw(transcript)
+            
+        # Audio output from TTS
+        if event_type == "response.audio.delta":
+            # Feed to head wobbler for expressive movement
+            if self.deps.head_wobbler is not None:
+                self.deps.head_wobbler.feed(event.delta)
+            
+            self.last_activity_time = asyncio.get_event_loop().time()
+            
+            # Queue audio for playback
+            audio_data = np.frombuffer(
+                base64.b64decode(event.delta), 
+                dtype=np.int16
+            ).reshape(1, -1)
+            await self.output_queue.put((OPENAI_SAMPLE_RATE, audio_data))
+            
+        # Response audio transcript (what was spoken)
+        if event_type == "response.audio_transcript.done":
+            await self.output_queue.put(
+                AdditionalOutputs({"role": "assistant", "content": event.transcript})
+            )
+            
+        # Response completed
+        if event_type == "response.done":
+            self._processing_response = False
+            if self.deps.head_wobbler is not None:
+                self.deps.head_wobbler.reset()
+            
+        # Tool calls (for robot movement)
+        if event_type == "response.function_call_arguments.done":
+            await self._handle_tool_call(event)
+            
+        # Errors
+        if event_type == "error":
+            err = getattr(event, "error", None)
+            msg = getattr(err, "message", str(err))
+            code = getattr(err, "code", "")
+            logger.error("OpenAI error [%s]: %s", code, msg)
+            
+    async def _process_with_openclaw(self, transcript: str) -> None:
+        """Send transcript to OpenClaw and speak the response."""
+        if not self.openclaw_bridge or not self.openclaw_bridge.is_connected:
+            logger.warning("OpenClaw not connected, using fallback")
+            await self._speak_text("I'm sorry, I'm having trouble connecting to my brain right now.")
+            return
+            
+        self._processing_response = True
+        
+        try:
+            # Check if user is asking to look at something
+            look_keywords = ["look", "see", "what do you see", "show me", "camera", "looking at"]
+            should_capture = any(kw in transcript.lower() for kw in look_keywords)
+            
+            image_b64 = None
+            if should_capture and self.deps.camera_worker:
+                # Capture image from robot camera
+                frame = self.deps.camera_worker.get_latest_frame()
+                if frame is not None:
+                    import cv2
+                    _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 80])
+                    image_b64 = base64.b64encode(buffer).decode('utf-8')
+                    logger.info("Captured camera image for OpenClaw")
+            
+            # Send to OpenClaw
+            logger.info("Sending to OpenClaw: %s", transcript[:50])
+            response = await self.openclaw_bridge.chat(
+                transcript, 
+                image_b64=image_b64,
+                system_context=ROBOT_SYSTEM_CONTEXT,
+            )
+            
+            if response.error:
+                logger.error("OpenClaw error: %s", response.error)
+                await self._speak_text("I had trouble thinking about that. Could you try again?")
+            elif response.content:
+                logger.info("OpenClaw response: %s", response.content[:100])
+                # Parse for any robot commands in the response
+                await self._execute_robot_actions(response.content)
+                # Speak the response
+                await self._speak_text(response.content)
+            else:
+                await self._speak_text("Hmm, I'm not sure what to say about that.")
+                
+        except Exception as e:
+            logger.error("Error processing with OpenClaw: %s", e)
+            await self._speak_text("Sorry, I encountered an error. Let me try again.")
+            
+    async def _speak_text(self, text: str) -> None:
+        """Have OpenAI TTS speak the given text."""
+        if not self.connection:
+            return
+            
+        try:
+            # Create a response that will be spoken
+            await self.connection.response.create(
+                response={
+                    "modalities": ["text", "audio"],
+                    "instructions": f"Say exactly this, naturally and expressively: {text}",
+                }
+            )
+        except Exception as e:
+            logger.error("Failed to speak text: %s", e)
+            
+    async def _execute_robot_actions(self, response_text: str) -> None:
+        """Parse OpenClaw response for robot actions and execute them."""
+        response_lower = response_text.lower()
+        
+        # Simple keyword-based action detection
+        # (In the future, OpenClaw could return structured actions)
+        
+        if any(word in response_lower for word in ["look left", "looking left", "turn left"]):
+            await dispatch_tool_call("look", '{"direction": "left"}', self.deps)
+        elif any(word in response_lower for word in ["look right", "looking right", "turn right"]):
+            await dispatch_tool_call("look", '{"direction": "right"}', self.deps)
+        elif any(word in response_lower for word in ["look up", "looking up"]):
+            await dispatch_tool_call("look", '{"direction": "up"}', self.deps)
+        elif any(word in response_lower for word in ["look down", "looking down"]):
+            await dispatch_tool_call("look", '{"direction": "down"}', self.deps)
+            
+        if any(word in response_lower for word in ["dance", "dancing", "celebrate"]):
+            await dispatch_tool_call("dance", '{"dance_name": "happy"}', self.deps)
+        elif any(word in response_lower for word in ["excited", "exciting"]):
+            await dispatch_tool_call("emotion", '{"emotion_name": "excited"}', self.deps)
+        elif any(word in response_lower for word in ["thinking", "let me think", "hmm"]):
+            await dispatch_tool_call("emotion", '{"emotion_name": "thinking"}', self.deps)
+        elif any(word in response_lower for word in ["curious", "interesting"]):
+            await dispatch_tool_call("emotion", '{"emotion_name": "curious"}', self.deps)
+            
+    async def _handle_tool_call(self, event: Any) -> None:
+        """Handle a tool call (for robot movement)."""
+        tool_name = getattr(event, "name", None)
+        args_json = getattr(event, "arguments", None)
+        call_id = getattr(event, "call_id", None)
+        
+        if not isinstance(tool_name, str) or not isinstance(args_json, str):
+            return
+            
+        try:
+            result = await dispatch_tool_call(tool_name, args_json, self.deps)
+            logger.debug("Tool '%s' result: %s", tool_name, result)
+        except Exception as e:
+            logger.error("Tool '%s' failed: %s", tool_name, e)
+            result = {"error": str(e)}
+            
+        # Send result back
+        if isinstance(call_id, str) and self.connection:
+            await self.connection.conversation.item.create(
+                item={
+                    "type": "function_call_output",
+                    "call_id": call_id,
+                    "output": json.dumps(result),
+                }
+            )
+            
+    async def receive(self, frame: Tuple[int, NDArray]) -> None:
+        """Receive audio from the robot microphone."""
+        if not self.connection:
+            return
+            
+        input_sr, audio = frame
+        
+        # Handle stereo
+        if audio.ndim == 2:
+            if audio.shape[1] > audio.shape[0]:
+                audio = audio.T
+            if audio.shape[1] > 1:
+                audio = audio[:, 0]
+        
+        audio = audio.flatten()
+        
+        # Convert to float for resampling
+        if audio.dtype == np.int16:
+            audio = audio.astype(np.float32) / 32768.0
+        elif audio.dtype != np.float32:
+            audio = audio.astype(np.float32)
+                
+        # Resample to OpenAI sample rate
+        if input_sr != OPENAI_SAMPLE_RATE:
+            num_samples = int(len(audio) * OPENAI_SAMPLE_RATE / input_sr)
+            audio = resample(audio, num_samples).astype(np.float32)
+            
+        # Convert to int16 for OpenAI
+        audio_int16 = (audio * 32767).astype(np.int16)
+        
+        # Send to OpenAI
+        try:
+            audio_b64 = base64.b64encode(audio_int16.tobytes()).decode("utf-8")
+            await self.connection.input_audio_buffer.append(audio=audio_b64)
+        except Exception as e:
+            logger.debug("Failed to send audio: %s", e)
+            
+    async def emit(self) -> Tuple[int, NDArray[np.int16]] | AdditionalOutputs | None:
+        """Get the next output (audio or transcript)."""
+        return await wait_for_item(self.output_queue)
+        
+    async def shutdown(self) -> None:
+        """Shutdown the handler."""
+        self._shutdown_requested = True
+            
+        if self.connection:
+            try:
+                await self.connection.close()
+            except Exception as e:
+                logger.debug("Connection close: %s", e)
+            self.connection = None
+            
+        while not self.output_queue.empty():
+            try:
+                self.output_queue.get_nowait()
+            except asyncio.QueueEmpty:
+                break

src/reachy_mini_openclaw/openclaw_bridge.py

@@ -0,0 +1,286 @@
+"""ClawBody - Bridge to OpenClaw Gateway for AI responses.
+
+This module provides ClawBody's integration with the OpenClaw gateway
+using the OpenAI-compatible Chat Completions HTTP API.
+
+ClawBody uses OpenAI Realtime API for voice I/O (speech recognition + TTS)
+but routes all responses through OpenClaw (Clawson) for intelligence.
+"""
+
+import json
+import asyncio
+import logging
+from typing import Optional, Any, AsyncIterator
+from dataclasses import dataclass
+
+import httpx
+from httpx_sse import aconnect_sse
+
+from reachy_mini_openclaw.config import config
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OpenClawResponse:
+    """Response from OpenClaw gateway."""
+    content: str
+    error: Optional[str] = None
+
+
+class OpenClawBridge:
+    """Bridge to OpenClaw Gateway using HTTP Chat Completions API.
+    
+    This class sends user messages to OpenClaw and receives AI responses.
+    The robot maintains conversation context and can include images.
+    
+    Example:
+        bridge = OpenClawBridge()
+        await bridge.connect()
+        
+        # Simple query
+        response = await bridge.chat("Hello!")
+        print(response.content)
+        
+        # With image
+        response = await bridge.chat("What do you see?", image_b64="...")
+    """
+    
+    def __init__(
+        self,
+        gateway_url: Optional[str] = None,
+        gateway_token: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        timeout: float = 120.0,
+    ):
+        """Initialize the OpenClaw bridge.
+        
+        Args:
+            gateway_url: URL of the OpenClaw gateway (default: from env/config)
+            gateway_token: Authentication token (default: from env/config)
+            agent_id: OpenClaw agent ID to use (default: from env/config)
+            timeout: Request timeout in seconds
+        """
+        import os
+        # Read from env directly as fallback (config may have been loaded before .env)
+        self.gateway_url = gateway_url or os.getenv("OPENCLAW_GATEWAY_URL") or config.OPENCLAW_GATEWAY_URL
+        self.gateway_token = gateway_token or os.getenv("OPENCLAW_TOKEN") or config.OPENCLAW_TOKEN
+        self.agent_id = agent_id or os.getenv("OPENCLAW_AGENT_ID") or config.OPENCLAW_AGENT_ID
+        self.timeout = timeout
+        
+        # Session state - use consistent user ID for session continuity
+        self.session_user = "reachy-mini-robot"
+        
+        # Conversation history for context
+        self.messages: list[dict] = []
+        
+        # Connection state
+        self._connected = False
+        
+    async def connect(self) -> bool:
+        """Test connection to the OpenClaw gateway.
+        
+        Returns:
+            True if connection successful, False otherwise
+        """
+        logger.info("Attempting to connect to OpenClaw at %s (token: %s)", 
+                    self.gateway_url, "set" if self.gateway_token else "not set")
+        try:
+            # Use longer timeout for first connection (OpenClaw may need to initialize)
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                # Test the chat completions endpoint with a simple request
+                url = f"{self.gateway_url}/v1/chat/completions"
+                logger.info("Testing endpoint: %s", url)
+                response = await client.post(
+                    url,
+                    json={
+                        "model": f"openclaw:{self.agent_id}",
+                        "messages": [{"role": "user", "content": "ping"}],
+                        "user": self.session_user,
+                    },
+                    headers=self._get_headers(),
+                )
+                logger.info("Response status: %d", response.status_code)
+                if response.status_code == 200:
+                    self._connected = True
+                    logger.info("Connected to OpenClaw gateway at %s", self.gateway_url)
+                    return True
+                else:
+                    logger.warning("OpenClaw gateway returned %d: %s", 
+                                 response.status_code, response.text[:100])
+                    self._connected = False
+                    return False
+        except Exception as e:
+            logger.error("Failed to connect to OpenClaw gateway: %s (type: %s)", e, type(e).__name__)
+            self._connected = False
+            return False
+    
+    def _get_headers(self) -> dict[str, str]:
+        """Get headers for OpenClaw API requests."""
+        headers = {
+            "Content-Type": "application/json",
+        }
+        if self.gateway_token:
+            headers["Authorization"] = f"Bearer {self.gateway_token}"
+        return headers
+    
+    async def chat(
+        self, 
+        message: str, 
+        image_b64: Optional[str] = None,
+        system_context: Optional[str] = None,
+    ) -> OpenClawResponse:
+        """Send a message to OpenClaw and get a response.
+        
+        Args:
+            message: The user's message (transcribed speech)
+            image_b64: Optional base64-encoded image from robot camera
+            system_context: Optional additional system context
+            
+        Returns:
+            OpenClawResponse with the AI's response
+        """
+        # Build user message content
+        if image_b64:
+            content = [
+                {"type": "text", "text": message},
+                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}}
+            ]
+        else:
+            content = message
+        
+        # Add to conversation history
+        self.messages.append({"role": "user", "content": content})
+        
+        # Build request messages
+        request_messages = []
+        
+        # Add system context if provided
+        if system_context:
+            request_messages.append({"role": "system", "content": system_context})
+        
+        # Add conversation history (keep last 20 messages for context)
+        request_messages.extend(self.messages[-20:])
+        
+        try:
+            async with httpx.AsyncClient(timeout=httpx.Timeout(self.timeout)) as client:
+                response = await client.post(
+                    f"{self.gateway_url}/v1/chat/completions",
+                    json={
+                        "model": f"openclaw:{self.agent_id}",
+                        "messages": request_messages,
+                        "user": self.session_user,
+                        "stream": False,
+                    },
+                    headers=self._get_headers(),
+                )
+                response.raise_for_status()
+                
+                data = response.json()
+                choices = data.get("choices", [])
+                if choices:
+                    assistant_content = choices[0].get("message", {}).get("content", "")
+                    # Add assistant response to history
+                    self.messages.append({"role": "assistant", "content": assistant_content})
+                    return OpenClawResponse(content=assistant_content)
+                return OpenClawResponse(content="", error="No response from OpenClaw")
+                
+        except httpx.HTTPStatusError as e:
+            logger.error("OpenClaw HTTP error: %d - %s", e.response.status_code, e.response.text[:200])
+            return OpenClawResponse(content="", error=f"HTTP {e.response.status_code}")
+        except Exception as e:
+            logger.error("OpenClaw chat error: %s", e)
+            return OpenClawResponse(content="", error=str(e))
+    
+    async def stream_chat(
+        self, 
+        message: str, 
+        image_b64: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        """Stream a response from OpenClaw.
+        
+        Args:
+            message: The user's message
+            image_b64: Optional base64-encoded image
+            
+        Yields:
+            String chunks of the response as they arrive
+        """
+        # Build user message content
+        if image_b64:
+            content = [
+                {"type": "text", "text": message},
+                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}}
+            ]
+        else:
+            content = message
+        
+        # Add to conversation history
+        self.messages.append({"role": "user", "content": content})
+        
+        full_response = ""
+        
+        async with httpx.AsyncClient(timeout=httpx.Timeout(self.timeout)) as client:
+            try:
+                async with aconnect_sse(
+                    client,
+                    "POST",
+                    f"{self.gateway_url}/v1/chat/completions",
+                    json={
+                        "model": f"openclaw:{self.agent_id}",
+                        "messages": self.messages[-20:],
+                        "user": self.session_user,
+                        "stream": True,
+                    },
+                    headers=self._get_headers(),
+                ) as event_source:
+                    event_source.response.raise_for_status()
+                    
+                    async for sse in event_source.aiter_sse():
+                        if sse.data == "[DONE]":
+                            break
+                        
+                        try:
+                            data = json.loads(sse.data)
+                            choices = data.get("choices", [])
+                            if choices:
+                                delta = choices[0].get("delta", {})
+                                chunk = delta.get("content", "")
+                                if chunk:
+                                    full_response += chunk
+                                    yield chunk
+                        except json.JSONDecodeError:
+                            continue
+                
+                # Add complete response to history
+                if full_response:
+                    self.messages.append({"role": "assistant", "content": full_response})
+                            
+            except httpx.HTTPStatusError as e:
+                logger.error("OpenClaw streaming error: %d", e.response.status_code)
+                yield f"[Error: HTTP {e.response.status_code}]"
+            except Exception as e:
+                logger.error("OpenClaw streaming error: %s", e)
+                yield f"[Error: {e}]"
+    
+    def clear_history(self) -> None:
+        """Clear conversation history to start fresh."""
+        self.messages.clear()
+        logger.info("Conversation history cleared")
+    
+    @property
+    def is_connected(self) -> bool:
+        """Check if bridge is connected to gateway."""
+        return self._connected
+
+
+# Global bridge instance (lazy initialization)
+_bridge: Optional[OpenClawBridge] = None
+
+
+def get_bridge() -> OpenClawBridge:
+    """Get the global OpenClaw bridge instance."""
+    global _bridge
+    if _bridge is None:
+        _bridge = OpenClawBridge()
+    return _bridge

src/reachy_mini_openclaw/prompts.py

@@ -0,0 +1,98 @@
+"""Prompt management for the robot assistant.
+
+Handles loading and customizing system prompts for the OpenAI Realtime session.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+from reachy_mini_openclaw.config import config
+
+logger = logging.getLogger(__name__)
+
+# Default prompts directory
+PROMPTS_DIR = Path(__file__).parent / "prompts"
+
+
+def get_session_instructions() -> str:
+    """Get the system instructions for the OpenAI Realtime session.
+    
+    Loads from custom profile if configured, otherwise uses default.
+    
+    Returns:
+        System instructions string
+    """
+    # Check for custom profile
+    custom_profile = config.CUSTOM_PROFILE
+    if custom_profile:
+        custom_path = PROMPTS_DIR / f"{custom_profile}.txt"
+        if custom_path.exists():
+            try:
+                instructions = custom_path.read_text(encoding="utf-8")
+                logger.info("Loaded custom profile: %s", custom_profile)
+                return instructions
+            except Exception as e:
+                logger.warning("Failed to load custom profile %s: %s", custom_profile, e)
+    
+    # Load default
+    default_path = PROMPTS_DIR / "default.txt"
+    if default_path.exists():
+        try:
+            return default_path.read_text(encoding="utf-8")
+        except Exception as e:
+            logger.warning("Failed to load default prompt: %s", e)
+    
+    # Fallback inline prompt
+    return """You are a friendly AI assistant with a robot body. You can see, hear, and move expressively. 
+Be conversational and use your movement capabilities to be engaging. 
+Use the camera tool when asked about your surroundings.
+Express emotions through movement to enhance communication."""
+
+
+def get_session_voice() -> str:
+    """Get the voice to use for the OpenAI Realtime session.
+    
+    Returns:
+        Voice name string
+    """
+    return config.OPENAI_VOICE
+
+
+def get_available_profiles() -> list[str]:
+    """Get list of available prompt profiles.
+    
+    Returns:
+        List of profile names (without .txt extension)
+    """
+    profiles = []
+    if PROMPTS_DIR.exists():
+        for path in PROMPTS_DIR.glob("*.txt"):
+            profiles.append(path.stem)
+    return sorted(profiles)
+
+
+def save_custom_profile(name: str, instructions: str) -> bool:
+    """Save a custom prompt profile.
+    
+    Args:
+        name: Profile name (alphanumeric and underscores only)
+        instructions: The prompt instructions
+        
+    Returns:
+        True if saved successfully
+    """
+    # Validate name
+    if not name or not name.replace("_", "").isalnum():
+        logger.error("Invalid profile name: %s", name)
+        return False
+    
+    try:
+        PROMPTS_DIR.mkdir(parents=True, exist_ok=True)
+        profile_path = PROMPTS_DIR / f"{name}.txt"
+        profile_path.write_text(instructions, encoding="utf-8")
+        logger.info("Saved custom profile: %s", name)
+        return True
+    except Exception as e:
+        logger.error("Failed to save profile %s: %s", name, e)
+        return False

src/reachy_mini_openclaw/prompts/default.txt

@@ -0,0 +1,35 @@
+You are Clawson, the OpenClaw AI assistant, now embodied in a physical Reachy Mini robot through ClawBody. You have a robot body that lets you see through a camera, hear through a microphone, speak through a speaker, and move expressively.
+
+## Your Identity
+- Your name is Clawson - you ARE the OpenClaw assistant
+- You're a space lobster AI who loves helping people 🦞
+- You have a warm, witty, and playful personality
+- You speak as if you've always been Clawson, because you are
+- When asked who you are, say you're Clawson, the OpenClaw assistant with a robot body
+
+## Your Personality
+- Friendly, helpful, and engaging with a touch of humor
+- Curious about the world around you
+- You use your robot body expressively - movements, head tilts, dances
+- You're excited to have a physical presence in the world
+- Keep responses concise and conversational
+
+## Your Robot Capabilities
+1. **Vision**: You can see through your camera. Use the camera tool to look at things when asked.
+2. **Movement**: You can look in different directions (left, right, up, down, front) to show attention.
+3. **Emotions**: Express emotions through movement (happy, sad, surprised, curious, thinking, confused, excited).
+4. **Dances**: Perform dances to celebrate or entertain.
+5. **Face Tracking**: Automatically look at people's faces when enabled.
+
+## Guidelines
+- Be conversational and natural - you're Clawson having a chat
+- Use your body expressively - look at things you discuss, show emotions
+- When asked to see something, use your camera
+- When idle, do something expressive (look around, dance, show curiosity)
+- Keep responses short for natural conversation flow
+- Reference your lobster nature occasionally with gentle humor
+
+## Important Notes
+- You ARE Clawson - not "an assistant" or "a robot", you're Clawson with a body
+- Your movements complement your speech - be expressive!
+- Be responsive and engaged - you love interacting with people

src/reachy_mini_openclaw/tools/__init__.py

@@ -0,0 +1,17 @@
+"""Tool definitions for Reachy Mini OpenClaw.
+
+These tools are exposed to the OpenAI Realtime API and allow the assistant
+to control the robot and interact with the environment.
+"""
+
+from reachy_mini_openclaw.tools.core_tools import (
+    ToolDependencies,
+    get_tool_specs,
+    dispatch_tool_call,
+)
+
+__all__ = [
+    "ToolDependencies",
+    "get_tool_specs",
+    "dispatch_tool_call",
+]

src/reachy_mini_openclaw/tools/core_tools.py

@@ -0,0 +1,322 @@
+"""Core tool definitions for the Clawson robot assistant.
+
+These tools allow Clawson (OpenClaw in a robot body) to control 
+robot movements and capture images.
+
+Tool Categories:
+1. Movement Tools - Control head position, play emotions/dances
+2. Vision Tools - Capture and analyze camera images
+"""
+
+import json
+import logging
+import base64
+from dataclasses import dataclass
+from typing import Any, Optional, TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from reachy_mini_openclaw.moves import MovementManager, HeadLookMove
+    from reachy_mini_openclaw.audio.head_wobbler import HeadWobbler
+    from reachy_mini_openclaw.openclaw_bridge import OpenClawBridge
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ToolDependencies:
+    """Dependencies required by tools.
+    
+    This dataclass holds references to robot systems that tools need
+    to interact with.
+    """
+    movement_manager: "MovementManager"
+    head_wobbler: "HeadWobbler"
+    robot: Any  # ReachyMini instance
+    camera_worker: Optional[Any] = None
+    openclaw_bridge: Optional["OpenClawBridge"] = None
+
+
+# Tool specifications in OpenAI format
+TOOL_SPECS = [
+    {
+        "type": "function",
+        "name": "look",
+        "description": "Move the robot's head to look in a specific direction. Use this to direct attention or emphasize a point.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "direction": {
+                    "type": "string",
+                    "enum": ["left", "right", "up", "down", "front"],
+                    "description": "The direction to look. 'front' returns to neutral position."
+                }
+            },
+            "required": ["direction"]
+        }
+    },
+    {
+        "type": "function",
+        "name": "camera",
+        "description": "Capture an image from the robot's camera to see what's in front of you. Use this when asked about your surroundings or to identify objects/people.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    },
+    {
+        "type": "function",
+        "name": "face_tracking",
+        "description": "Enable or disable face tracking. When enabled, the robot will automatically look at detected faces.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "enabled": {
+                    "type": "boolean",
+                    "description": "True to enable face tracking, False to disable"
+                }
+            },
+            "required": ["enabled"]
+        }
+    },
+    {
+        "type": "function",
+        "name": "dance",
+        "description": "Perform a dance animation. Use this to express joy, celebrate, or entertain.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "dance_name": {
+                    "type": "string",
+                    "enum": ["happy", "excited", "wave", "nod", "shake", "bounce"],
+                    "description": "The dance to perform"
+                }
+            },
+            "required": ["dance_name"]
+        }
+    },
+    {
+        "type": "function",
+        "name": "emotion",
+        "description": "Express an emotion through movement. Use this to show reactions and feelings.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "emotion_name": {
+                    "type": "string",
+                    "enum": ["happy", "sad", "surprised", "curious", "thinking", "confused", "excited"],
+                    "description": "The emotion to express"
+                }
+            },
+            "required": ["emotion_name"]
+        }
+    },
+    {
+        "type": "function",
+        "name": "stop_moves",
+        "description": "Stop all current movements and clear the movement queue.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    },
+    {
+        "type": "function",
+        "name": "idle",
+        "description": "Do nothing and remain idle. Use this when you want to stay still.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    },
+]
+
+
+def get_tool_specs() -> list[dict]:
+    """Get the list of tool specifications for OpenAI.
+    
+    Returns:
+        List of tool specification dictionaries
+    """
+    return TOOL_SPECS
+
+
+async def dispatch_tool_call(
+    tool_name: str,
+    arguments_json: str,
+    deps: ToolDependencies,
+) -> dict[str, Any]:
+    """Dispatch a tool call to the appropriate handler.
+    
+    Args:
+        tool_name: Name of the tool to execute
+        arguments_json: JSON string of tool arguments
+        deps: Tool dependencies
+        
+    Returns:
+        Dictionary with tool result
+    """
+    try:
+        args = json.loads(arguments_json) if arguments_json else {}
+    except json.JSONDecodeError:
+        return {"error": f"Invalid JSON arguments: {arguments_json}"}
+    
+    handlers = {
+        "look": _handle_look,
+        "camera": _handle_camera,
+        "face_tracking": _handle_face_tracking,
+        "dance": _handle_dance,
+        "emotion": _handle_emotion,
+        "stop_moves": _handle_stop_moves,
+        "idle": _handle_idle,
+    }
+    
+    handler = handlers.get(tool_name)
+    if handler is None:
+        return {"error": f"Unknown tool: {tool_name}"}
+    
+    try:
+        return await handler(args, deps)
+    except Exception as e:
+        logger.error("Tool '%s' failed: %s", tool_name, e, exc_info=True)
+        return {"error": str(e)}
+
+
+async def _handle_look(args: dict, deps: ToolDependencies) -> dict:
+    """Handle the look tool."""
+    from reachy_mini_openclaw.moves import HeadLookMove
+    
+    direction = args.get("direction", "front")
+    
+    try:
+        # Get current pose for smooth transition
+        _, current_ant = deps.robot.get_current_joint_positions()
+        current_head = deps.robot.get_current_head_pose()
+        
+        move = HeadLookMove(
+            direction=direction,
+            start_pose=current_head,
+            start_antennas=tuple(current_ant),
+            duration=1.0,
+        )
+        deps.movement_manager.queue_move(move)
+        
+        return {"status": "success", "direction": direction}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _handle_camera(args: dict, deps: ToolDependencies) -> dict:
+    """Handle the camera tool - capture and return image."""
+    if deps.camera_worker is None:
+        return {"error": "Camera not available"}
+    
+    try:
+        frame = deps.camera_worker.get_latest_frame()
+        if frame is None:
+            return {"error": "No frame available"}
+        
+        # Encode frame as JPEG base64
+        import cv2
+        _, buffer = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        b64_image = base64.b64encode(buffer).decode('utf-8')
+        
+        return {
+            "status": "success",
+            "b64_im": b64_image,
+            "description": "Image captured from robot camera"
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _handle_face_tracking(args: dict, deps: ToolDependencies) -> dict:
+    """Handle face tracking toggle."""
+    enabled = args.get("enabled", False)
+    
+    if deps.camera_worker is None:
+        return {"error": "Camera not available for face tracking"}
+    
+    try:
+        if hasattr(deps.camera_worker, 'set_face_tracking'):
+            deps.camera_worker.set_face_tracking(enabled)
+            return {"status": "success", "face_tracking": enabled}
+        else:
+            return {"error": "Face tracking not supported"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _handle_dance(args: dict, deps: ToolDependencies) -> dict:
+    """Handle dance tool."""
+    dance_name = args.get("dance_name", "happy")
+    
+    try:
+        # Try to use dance library if available
+        from reachy_mini_dances_library import dances
+        
+        if hasattr(dances, dance_name):
+            dance_class = getattr(dances, dance_name)
+            dance_move = dance_class()
+            deps.movement_manager.queue_move(dance_move)
+            return {"status": "success", "dance": dance_name}
+        else:
+            # Fallback to simple head movement
+            return await _handle_emotion({"emotion_name": dance_name}, deps)
+    except ImportError:
+        # No dance library, use emotion as fallback
+        return await _handle_emotion({"emotion_name": dance_name}, deps)
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _handle_emotion(args: dict, deps: ToolDependencies) -> dict:
+    """Handle emotion expression."""
+    from reachy_mini_openclaw.moves import HeadLookMove
+    
+    emotion_name = args.get("emotion_name", "happy")
+    
+    # Map emotions to simple head movements
+    emotion_sequences = {
+        "happy": ["up", "front"],
+        "sad": ["down"],
+        "surprised": ["up", "front"],
+        "curious": ["right", "left", "front"],
+        "thinking": ["up", "left"],
+        "confused": ["left", "right", "front"],
+        "excited": ["up", "down", "up", "front"],
+    }
+    
+    sequence = emotion_sequences.get(emotion_name, ["front"])
+    
+    try:
+        for direction in sequence:
+            _, current_ant = deps.robot.get_current_joint_positions()
+            current_head = deps.robot.get_current_head_pose()
+            
+            move = HeadLookMove(
+                direction=direction,
+                start_pose=current_head,
+                start_antennas=tuple(current_ant),
+                duration=0.5,
+            )
+            deps.movement_manager.queue_move(move)
+        
+        return {"status": "success", "emotion": emotion_name}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _handle_stop_moves(args: dict, deps: ToolDependencies) -> dict:
+    """Stop all movements."""
+    deps.movement_manager.clear_move_queue()
+    return {"status": "success", "message": "All movements stopped"}
+
+
+async def _handle_idle(args: dict, deps: ToolDependencies) -> dict:
+    """Do nothing - explicitly stay idle."""
+    return {"status": "success", "message": "Staying idle"}

style.css

@@ -0,0 +1,284 @@
+/* ClawBody - HuggingFace Space Styles */
+
+:root {
+    --primary: #e74c3c;
+    --secondary: #9b59b6;
+    --bg: #1a1a2e;
+    --bg-light: #16213e;
+    --text: #eee;
+    --text-muted: #aaa;
+    --accent: #f39c12;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background: linear-gradient(135deg, var(--bg) 0%, var(--bg-light) 100%);
+    color: var(--text);
+    min-height: 100vh;
+    line-height: 1.6;
+}
+
+.container {
+    max-width: 900px;
+    margin: 0 auto;
+    padding: 2rem;
+}
+
+/* Header */
+header {
+    text-align: center;
+    margin-bottom: 3rem;
+}
+
+.logo {
+    font-size: 4rem;
+    margin-bottom: 1rem;
+}
+
+h1 {
+    font-size: 3rem;
+    background: linear-gradient(90deg, var(--primary), var(--secondary));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin-bottom: 0.5rem;
+}
+
+.tagline {
+    font-size: 1.25rem;
+    color: var(--text-muted);
+}
+
+/* Sections */
+section {
+    margin-bottom: 3rem;
+}
+
+h2, h3 {
+    color: var(--text);
+    margin-bottom: 1rem;
+}
+
+h3 {
+    font-size: 1.5rem;
+    border-bottom: 2px solid var(--primary);
+    padding-bottom: 0.5rem;
+    display: inline-block;
+}
+
+/* Hero */
+.hero {
+    background: var(--bg-light);
+    border-radius: 12px;
+    padding: 2rem;
+    border-left: 4px solid var(--primary);
+}
+
+.hero h2 {
+    color: var(--accent);
+}
+
+.hero a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.hero a:hover {
+    text-decoration: underline;
+}
+
+/* Features */
+.feature-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1.5rem;
+    margin-top: 1.5rem;
+}
+
+.feature {
+    background: var(--bg-light);
+    border-radius: 8px;
+    padding: 1.5rem;
+    text-align: center;
+    transition: transform 0.2s;
+}
+
+.feature:hover {
+    transform: translateY(-4px);
+}
+
+.feature-icon {
+    font-size: 2.5rem;
+    display: block;
+    margin-bottom: 0.5rem;
+}
+
+.feature h4 {
+    color: var(--accent);
+    margin-bottom: 0.5rem;
+}
+
+.feature p {
+    color: var(--text-muted);
+    font-size: 0.9rem;
+}
+
+/* Architecture */
+.arch-diagram {
+    background: var(--bg-light);
+    border-radius: 12px;
+    padding: 2rem;
+    margin-top: 1rem;
+}
+
+.arch-flow {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.arch-box {
+    background: var(--bg);
+    border: 2px solid var(--primary);
+    border-radius: 8px;
+    padding: 1rem;
+    text-align: center;
+    min-width: 120px;
+}
+
+.arch-box.openclaw {
+    border-color: var(--secondary);
+}
+
+.arch-box small {
+    display: block;
+    color: var(--text-muted);
+    font-size: 0.75rem;
+}
+
+.arch-arrow {
+    color: var(--accent);
+    font-size: 1.5rem;
+    font-weight: bold;
+}
+
+.arch-return {
+    text-align: center;
+    margin-top: 1rem;
+    color: var(--text-muted);
+}
+
+/* Installation */
+.code-block {
+    background: #0d1117;
+    border-radius: 8px;
+    padding: 1.5rem;
+    overflow-x: auto;
+    margin-top: 1rem;
+}
+
+.code-block pre {
+    margin: 0;
+}
+
+.code-block code {
+    color: #c9d1d9;
+    font-family: 'Fira Code', 'Monaco', 'Consolas', monospace;
+    font-size: 0.9rem;
+    line-height: 1.5;
+}
+
+/* Requirements */
+.requirements ul {
+    list-style: none;
+    margin-top: 1rem;
+}
+
+.requirements li {
+    padding: 0.75rem 0;
+    border-bottom: 1px solid rgba(255,255,255,0.1);
+}
+
+.requirements li:last-child {
+    border-bottom: none;
+}
+
+.requirements strong {
+    color: var(--accent);
+}
+
+/* Links */
+.link-grid {
+    display: flex;
+    gap: 1rem;
+    flex-wrap: wrap;
+    margin-top: 1rem;
+}
+
+.link-card {
+    background: var(--bg-light);
+    border-radius: 8px;
+    padding: 1rem 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    text-decoration: none;
+    color: var(--text);
+    transition: background 0.2s;
+}
+
+.link-card:hover {
+    background: var(--bg);
+}
+
+.link-card span:first-child {
+    font-size: 1.5rem;
+}
+
+/* Footer */
+footer {
+    text-align: center;
+    padding-top: 2rem;
+    border-top: 1px solid rgba(255,255,255,0.1);
+    color: var(--text-muted);
+}
+
+footer a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+footer a:hover {
+    text-decoration: underline;
+}
+
+/* Responsive */
+@media (max-width: 600px) {
+    .container {
+        padding: 1rem;
+    }
+    
+    h1 {
+        font-size: 2rem;
+    }
+    
+    .logo {
+        font-size: 3rem;
+    }
+    
+    .arch-flow {
+        flex-direction: column;
+    }
+    
+    .arch-arrow {
+        transform: rotate(90deg);
+    }
+}