commit 63f081d3051412d11053176e1e54ed503754bf5e
Author: Craft Agent <agents-noreply@craft.do>
Date:   Tue Feb 10 09:27:28 2026 +0400

    Add comprehensive comparison review: OpenClaw vs NanoBot vs PicoClaw
    
    - Human-like comparison of three AI assistant projects
    - Detailed installation guides for each project
    - Use-case based recommendations
    - Resource requirements comparison
    
    Co-Authored-By: Craft Agent <agents-noreply@craft.do>

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..cdfa288
--- /dev/null
+++ b/README.md
@@ -0,0 +1,442 @@
+# OpenClaw vs NanoBot vs PicoClaw: A Friendly Comparison
+
+*Published: February 10, 2026*
+
+---
+
+## Introduction
+
+So you're looking for a personal AI assistant you can run yourself? That's awesome! I've spent time exploring three fascinating projects in this space: **OpenClaw**, **NanoBot**, and **PicoClaw**. Each has its own personality and strengths, and I'm here to help you understand which one might be the best fit for your needs.
+
+Let me be upfront: all three of these projects are part of the same "Claw" family. OpenClaw is the original feature-rich assistant, while NanoBot and PicoClaw are lightweight reimaginings that strip things down to the essentials. It's kind of like comparing a Swiss Army knife (OpenClaw) to a sleek pocket knife (NanoBot) and a tiny keychain tool (PicoClaw) - each has its place!
+
+---
+
+## Quick Overview Table
+
+| Feature | OpenClaw | NanoBot | PicoClaw |
+|---------|----------|---------|----------|
+| **Language** | TypeScript | Python | Go |
+| **Code Size** | 430,000+ lines | ~3,510 lines | Ultra-compact |
+| **Memory Usage** | >1GB RAM | >100MB RAM | <10MB RAM |
+| **Startup Time** | >500s (0.8GHz) | >30s | <1s |
+| **Hardware Cost** | ~$599 (Mac Mini) | ~$50 (Linux SBC) | ~$10 (any Linux board) |
+| **Multi-Channel** | 12+ platforms | 8 platforms | 2 platforms |
+| **Voice Support** | Yes (Wake+Talk) | Via Groq | Via Groq |
+| **Best For** | Power users, everything | Researchers, tinkerers | Edge devices, minimalism |
+
+---
+
+## OpenClaw 🦞
+### *The "Everything But the Kitchen Sink" Powerhouse*
+
+**What it is:** OpenClaw is the original, feature-complete personal AI assistant. If you want it all, this is your project.
+
+**Who it's for:**
+- Power users who want maximum features
+- People who use multiple messaging platforms daily
+- Those who want voice interaction (Wake + Talk mode)
+- Users who value a polished, production-ready experience
+
+**What makes it special:**
+OpenClaw is seriously impressive in scope. It supports **12+ messaging platforms** out of the box: WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage (via BlueBubbles), Microsoft Teams, Matrix, Zalo, WebChat, and has companion apps for macOS, iOS, and Android. The voice features are particularly cool - you can literally talk to your assistant using "Voice Wake" on mobile devices.
+
+The architecture is built around a **Gateway WebSocket control plane** that manages everything - sessions, channels, tools, events. It's designed to run as a daemon and has a beautiful Control UI for dashboard access.
+
+**Resource Reality Check:**
+Here's the trade-off - OpenClaw needs resources. We're talking >1GB of RAM and it can take over 8 minutes to start on slower hardware. The developers recommend running it on a Mac mini or similar machine, which means a ~$600 hardware investment.
+
+**Notable Features:**
+- Multi-agent routing (different agents for different conversations)
+- Live Canvas - an agent-driven visual workspace
+- Browser control with dedicated Chrome/Chromium
+- Skills platform with bundled, managed, and workspace skills
+- Tailscale integration for remote access
+- Comprehensive security model with sandboxing options
+- Huge community with 200+ contributors
+
+---
+
+## NanoBot 🐈
+### *The Researcher's Dream*
+
+**What it is:** NanoBot is an ultra-lightweight reimagining of OpenClaw, distilled down to about 3,510 lines of clean, readable Python code. That's 99% smaller than OpenClaw!
+
+**Who it's for:**
+- Researchers and students studying AI agent architecture
+- Developers who want to understand and modify the code
+- Hobbyists with basic Linux single-board computers
+- Python developers who want an assistant they can hack on
+
+**What makes it special:**
+The core philosophy here is simplicity and transparency. The code is intentionally designed to be readable and educational. If you've ever wanted to understand how an AI agent works under the hood, NanoBot is like having the blueprints handed to you.
+
+Despite being lightweight, NanoBot still supports **8 messaging platforms**: Telegram, Discord, WhatsApp, Feishu, DingTalk, Slack, Email, and QQ. The setup process for each is well-documented and the project includes Docker support for easy deployment.
+
+**Resource Reality Check:**
+NanoBot needs >100MB of RAM and boots in about 30 seconds. You can run it on a $50 Linux single-board computer like a Raspberry Pi, making it very accessible for hobbyists.
+
+**Notable Features:**
+- Clean architecture with agent loop, context management, memory, skills, and tools
+- Multi-provider LLM support (OpenRouter, Anthropic, OpenAI, DeepSeek, Groq, Gemini, etc.)
+- Local model support via vLLM
+- Scheduled tasks with cron support
+- Active development with frequent updates
+- Docker support for containerized deployment
+- Research-ready codebase
+
+---
+
+## PicoClaw 🦐
+### *The Extreme Minimalist*
+
+**What it is:** PicoClaw pushes minimalism to the extreme. Written in Go, it runs on $10 hardware with less than 10MB of RAM and boots in just 1 second. This is "AI agent on a shoestring" taken to its logical conclusion.
+
+**Who it's for:**
+- Edge computing enthusiasts
+- People running AI on embedded devices (RISC-V, ARM, x86)
+- Those who want a single self-contained binary
+- Developers who value extreme efficiency
+
+**What makes it special:**
+What's wild about PicoClaw is that it was **AI-bootstrapped** - the AI agent itself drove the architectural migration from Python to Go. About 95% of the core code was agent-generated with human-in-the-loop refinement. It's a fascinating experiment in AI-assisted development.
+
+PicoClaw is a true single binary - no dependencies, no complex setup, just download and run. It supports RISC-V, ARM, and x86 architectures, making it incredibly portable.
+
+**Resource Reality Check:**
+The specs are mind-blowing: <10MB RAM, 1-second boot time even on 0.6GHz single-core, and it can run on $10 Linux boards. This opens up possibilities that simply don't exist with the other two projects.
+
+**Notable Features:**
+- Currently supports Telegram and Discord
+- Self-contained single binary
+- Cross-platform compilation support
+- Multiple LLM providers (Zhipu, OpenRouter, Anthropic, etc.)
+- Web search integration (optional, via Brave API)
+- Designed for embedded and edge deployments
+
+---
+
+## Installation Guides
+
+### OpenClaw Installation
+
+**Prerequisites:**
+- Node.js ≥22
+- For daemon: systemd (Linux) or launchd (macOS)
+
+**Step 1: Install via npm**
+```bash
+npm install -g openclaw@latest
+# or: pnpm add -g openclaw@latest
+```
+
+**Step 2: Run the onboarding wizard**
+```bash
+openclaw onboard --install-daemon
+```
+This wizard will guide you through:
+- Setting up your configuration
+- Configuring LLM providers (Anthropic, OpenAI, etc.)
+- Setting up messaging channels
+- Installing the daemon as a system service
+
+**Step 3: Start the gateway**
+```bash
+openclaw gateway --port 18789 --verbose
+```
+
+**Step 4: Send your first message**
+```bash
+openclaw message send --to +1234567890 --message "Hello from OpenClaw"
+```
+
+**Configuration File:** `~/.openclaw/openclaw.json`
+
+**Minimum Config:**
+```json
+{
+  "agent": {
+    "model": "anthropic/claude-opus-4-6"
+  }
+}
+```
+
+**Pro Tips:**
+- The onboarding wizard is genuinely helpful - use it!
+- You'll need API keys from Anthropic, OpenAI, or another provider
+- Start with one channel (Telegram is easiest) and expand from there
+- Check the docs for channel-specific setup instructions
+
+---
+
+### NanoBot Installation
+
+**Prerequisites:**
+- Python 3.8+
+- pip
+
+**Step 1: Install from source (recommended)**
+```bash
+git clone https://github.com/HKUDS/nanobot.git
+cd nanobot
+pip install -e .
+```
+
+**Alternative: Install with uv (faster)**
+```bash
+uv tool install nanobot-ai
+```
+
+**Step 2: Initialize**
+```bash
+nanobot onboard
+```
+
+**Step 3: Configure** (`~/.nanobot/config.json`)
+
+For OpenRouter (recommended):
+```json
+{
+  "providers": {
+    "openrouter": {
+      "apiKey": "sk-or-v1-xxx"
+    }
+  },
+  "agents": {
+    "defaults": {
+      "model": "anthropic/claude-opus-4-5"
+    }
+  }
+}
+```
+
+**Step 4: Test it**
+```bash
+nanobot agent -m "What is 2+2?"
+```
+
+**Step 5: Connect a channel (Telegram example)**
+
+1. Create a bot via [@BotFather](https://t.me/botfather) on Telegram
+2. Copy the token
+3. Update your config:
+```json
+{
+  "channels": {
+    "telegram": {
+      "enabled": true,
+      "token": "YOUR_BOT_TOKEN",
+      "allowFrom": ["YOUR_USER_ID"]
+    }
+  }
+}
+```
+
+4. Run the gateway:
+```bash
+nanobot gateway
+```
+
+**Docker Option:**
+```bash
+docker build -t nanobot .
+docker run -v ~/.nanobot:/root/.nanobot -p 18790:18790 nanobot gateway
+```
+
+**Pro Tips:**
+- Get your Telegram User ID from [@userinfobot](https://t.me/userinfobot)
+- Groq provides free voice transcription if you want voice features
+- The codebase is very readable - don't be afraid to explore and modify!
+
+---
+
+### PicoClaw Installation
+
+**Prerequisites:**
+- Go 1.21+ (if building from source)
+- Linux (any distro)
+
+**Step 1: Install from source**
+```bash
+git clone https://github.com/sipeed/picoclaw.git
+cd picoclaw
+make deps
+make build
+# or: make install
+```
+
+**Alternative: Download pre-built binary**
+Visit the [releases page](https://github.com/sipeed/picoclaw/releases) and download the appropriate binary for your platform.
+
+**Step 2: Configure** (`~/.picoclaw/config.json`)
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "workspace": "~/.picoclaw/workspace",
+      "model": "glm-4.7",
+      "max_tokens": 8192,
+      "temperature": 0.7,
+      "max_tool_iterations": 20
+    }
+  },
+  "providers": {
+    "zhipu": {
+      "api_key": "YOUR_API_KEY",
+      "api_base": "https://open.bigmodel.cn/api/paas/v4"
+    }
+  },
+  "tools": {
+    "web": {
+      "search": {
+        "api_key": "YOUR_BRAVE_API_KEY",
+        "max_results": 5
+      }
+    }
+  }
+}
+```
+
+**Step 3: Test it**
+```bash
+picoclaw agent -m "What is 2+2?"
+```
+
+**Step 4: Connect Telegram**
+
+1. Create bot via [@BotFather](https://t.me/botfather)
+2. Update config:
+```json
+{
+  "channels": {
+    "telegram": {
+      "enabled": true,
+      "token": "YOUR_BOT_TOKEN",
+      "allowFrom": ["YOUR_USER_ID"]
+    }
+  }
+}
+```
+
+3. Run:
+```bash
+picoclaw gateway
+```
+
+**Cross-compilation:**
+```bash
+make build-all  # Builds for all platforms
+```
+
+**Pro Tips:**
+- Web search is optional - PicoClaw works fine without it
+- Brave Search has a free tier (2000 queries/month)
+- PicoClaw is designed for embedded use - perfect for edge devices
+
+---
+
+## Comparison by Use Case
+
+### "I want everything to work out of the box"
+**Choose: OpenClaw**
+- Most polished user experience
+- Supports every platform you can think of
+- Voice features are genuinely useful
+- Large community = better support
+- Best documentation
+
+### "I want to learn how AI agents work"
+**Choose: NanoBot**
+- Clean, readable Python code
+- Educational architecture
+- Easy to modify and extend
+- Active research community
+- Great for students and researchers
+
+### "I want to run AI on a $10 computer"
+**Choose: PicoClaw**
+- Extreme minimalism
+- Runs on hardware nothing else can
+- Single binary - no dependency hell
+- Fastest startup time by far
+- Perfect for edge deployments
+
+### "I'm a Python developer"
+**Choose: NanoBot**
+- Native Python implementation
+- Uses familiar Python patterns
+- Easy to extend with Python packages
+- Great integration with Python ML ecosystem
+
+### "I need production-ready reliability"
+**Choose: OpenClaw**
+- Most mature codebase
+- Comprehensive error handling
+- Security sandboxing
+- Daemon mode with proper service management
+- Battle-tested by large community
+
+### "I'm experimenting with embedded AI"
+**Choose: PicoClaw**
+- Designed for embedded from day one
+- RISC-V support
+- Tiny resource footprint
+- Self-contained deployment
+
+---
+
+## My Honest Take
+
+After spending time with all three projects, here's my perspective:
+
+**OpenClaw** is like owning a luxury car - it's expensive (in resources), has every feature imaginable, and delivers a premium experience. If you have the hardware and want the best possible personal AI assistant, it's hard to beat. The voice features alone are worth it for some people.
+
+**NanoBot** hits a sweet spot that I really appreciate. It's lightweight enough to run on modest hardware but still retains enough functionality to be genuinely useful. What I love most is that you can actually read and understand the code. If you're the type of person who likes to tinker and modify your tools, NanoBot is a joy to work with.
+
+**PicoClaw** is fascinating as a proof of concept. Running an AI assistant on $10 hardware with 10MB of RAM is legitimately impressive. But the trade-off is real - you only get Telegram and Discord support, and the feature set is minimal. Still, for edge computing scenarios or just the satisfaction of doing more with less, PicoClaw is a remarkable achievement.
+
+---
+
+## Recommendation Guide
+
+| Your Situation | I Recommend |
+|----------------|-------------|
+| Have a Mac mini / powerful PC | **OpenClaw** |
+| Have a Raspberry Pi or similar | **NanoBot** |
+| Have a $10 Linux board | **PicoClaw** |
+| Want to study AI agent code | **NanoBot** |
+| Need WhatsApp support | **OpenClaw** |
+| Only need Telegram/Discord | **NanoBot** or **PicoClaw** |
+| Want voice interaction | **OpenClaw** |
+| Care about startup time | **PicoClaw** (1s!) |
+| Want many channel options | **OpenClaw** (12+) |
+| Want minimal complexity | **PicoClaw** |
+| Want educational code | **NanoBot** |
+| Need production reliability | **OpenClaw** |
+
+---
+
+## Conclusion
+
+The great thing about having three options is that there's probably one that matches your exact needs. OpenClaw, NanoBot, and PicoClaw represent different points on the complexity-resource spectrum, and all three are actively maintained with enthusiastic communities.
+
+My suggestion? Start with **NanoBot** if you're unsure. It hits a nice balance - not too heavy, not too minimal, and you'll learn a lot in the process. If you outgrow it, you can move up to OpenClaw. If you want to go even lighter, PicoClaw awaits.
+
+All three projects are testaments to the creativity and energy in the open-source AI community. Whichever you choose, you're getting a powerful personal AI assistant that you control - and that's something worth celebrating.
+
+---
+
+*Have questions? Each project has an active community:*
+- **OpenClaw:** [Discord](https://discord.gg/145635006406590486) · [GitHub Discussions](https://github.com/openclaw/openclaw/discussions)
+- **NanoBot:** [GitHub Issues](https://github.com/HKUDS/nanobot/issues)
+- **PicoClaw:** [Discord](https://discord.gg/V4sAZ9XWpN)
+
+---
+
+**Project Links:**
+- [OpenClaw](https://github.com/openclaw/openclaw)
+- [NanoBot](https://github.com/HKUDS/nanobot)
+- [PicoClaw](https://github.com/sipeed/picoclaw)
+
+*Last updated: February 10, 2026*