sipeed/picoclaw: Run an AI Assistant on $10 Hardware with <10MB RAM

Most AI assistants demand cloud GPUs, gigabytes of RAM, or expensive Apple Silicon. For developers building edge deployments, home labs, or cost-sensitive automation, that overhead is a dealbreaker. sipeed/picoclaw takes a different path: a personal AI assistant written entirely in Go, bootstrapped by AI itself, designed to run on hardware as cheap as $9.90 and lean enough to fit in under 10MB of memory.

This isn't a stripped-down proof-of-concept. With 29,756 GitHub stars, 4,451 forks, and an MIT License, PicoClaw has become one of the fastest-growing open-source AI agent projects. It supports 30+ LLM providers, 19+ messaging channels, native MCP (Model Context Protocol) integration, and deploys as a single static binary across x86_64, ARM64, MIPS, RISC-V, and LoongArch.

Whether you're automating a home server on a RISC-V board, resurrecting an old Android phone as a smart assistant, or building embedded AI that doesn't phone home to the cloud, PicoClaw offers a credible, production-leaning foundation.

What is sipeed/picoclaw?

PicoClaw is an open-source personal AI assistant initiated by Sipeed, a hardware company known for affordable RISC-V and edge-AI boards. The project is written entirely in Go 1.25+ from scratch—not a fork of OpenClaw, NanoBot, or any existing project.

The project's origin story is unusual: PicoClaw was rebuilt from the ground up through a "self-bootstrapping" process where the AI agent itself drove the architecture migration from another language to Go, with human-in-the-loop review refining the output. According to the project, 95% of core code was AI-generated, then tuned by maintainers.

The result is a tool that occupies a specific niche in the AI agent landscape. Where OpenClaw (TypeScript) demands over 1GB RAM and NanoBot (Python^{↗ Bright Coding Blog}) needs 100MB+, PicoClaw's core footprint is under 10MB—with the project noting that recent rapid development has pushed some builds to 10-20MB, with optimization planned after feature stabilization. Boot time is under 1 second even on a 0.6GHz single-core processor, compared to over 500 seconds for OpenClaw on similar hardware.

The project reached 20,000 stars in 17 days after its February 2026 release, and has continued climbing to nearly 30,000. The last commit was July 9, 2026, indicating active development.

Key Features

Ultra-lightweight core: The Go implementation achieves a memory footprint the project claims is 99% smaller than OpenClaw and 98% cheaper than a Mac mini for hardware costs. This isn't just marketing—the numbers are derived from documented comparisons on specific hardware configurations.

Cross-architecture portability: A single binary runs on x86_64, ARM64, MIPS, RISC-V, and LoongArch. This matters for embedded developers who need to deploy across heterogeneous hardware without maintaining multiple build pipelines.

30+ LLM providers: Native support for OpenAI, Anthropic, Google Gemini, DeepSeek, Qwen, Groq, Ollama, vLLM, Azure OpenAI, AWS^{↗ Bright Coding Blog} Bedrock, and many others. The protocol/model configuration format makes switching providers straightforward.

19+ messaging channels: Integrate with Telegram, Discord, WhatsApp, WeChat, QQ, Slack, Matrix, IRC, MQTT, and more. All webhook-based channels share a single Gateway HTTP server.

Native MCP support: Model Context Protocol integration allows connecting any MCP server to extend agent capabilities. CLI commands (picoclaw mcp add, list, test, edit, remove) manage configurations without hand-editing JSON.

Vision pipeline: Send images and files directly to the agent, with automatic base64 encoding for multimodal LLMs.

Smart model routing: Rule-based routing sends simple queries to lightweight models, reducing API costs for mixed-complexity workloads.

WebUI Launcher: A browser-based interface for configuration and chat, built with Node.js/pnpm, accessible at localhost:18800. No command-line knowledge required for basic setup.

Android support: Runs as a native APK or through Termux, enabling repurposing of old phones as dedicated AI assistants.

Use Cases

Edge AI on sub-$10 hardware: The LicheeRV-Nano at $9.90 is the project's poster child—a RISC-V board with Ethernet or WiFi6 that runs a functional home assistant. For developers building IoT or home automation that shouldn't depend on cloud connectivity, this is a genuinely viable deployment target.

Server automation with KVM: The NanoKVM ($30-50) and NanoKVM-Pro ($100) enable automated server operations without dedicating a full computer to management tasks. PicoClaw's sub-10MB footprint leaves resources for the actual KVM functionality.

Smart surveillance: The MaixCAM ($50) and MaixCAM2 ($100) integrate camera hardware with local AI processing. PicoClaw's vision pipeline and low resource usage make it suitable for always-on surveillance without cloud dependency.

Old phone resurrection: Android support via APK or Termux means decade-old phones become dedicated smart assistants. This is practical for developers with device drawers, or for deploying in locations where buying new hardware isn't feasible.

Development and testing: With 30+ providers and local deployment options (Ollama, vLLM), PicoClaw serves as a lightweight testbed for agent behaviors before deploying to production infrastructure.

Installation & Setup

Download from Official Website (Recommended)

Visit picoclaw.io—the site auto-detects your platform for one-click download.

Build from Source

Prerequisites:

• Go 1.25+
• Node.js 22+ and pnpm 10.33.0+ (for Web UI / launcher builds)

# Clone repository
git clone https://github.com/sipeed/picoclaw.git
cd picoclaw

# Install dependencies
make deps

# Install frontend dependencies
(cd web/frontend && pnpm install --frozen-lockfile)

# Build core binary for current platform
make build

# Build Web UI Launcher (required for WebUI mode)
make build-launcher

# Build for Raspberry Pi Zero 2 W
# 32-bit: make build-linux-arm
# 64-bit: make build-linux-arm64
make build-pi-zero

# Install to system
make install

The make build-pi-zero command builds both 32-bit and 64-bit variants. Use the binary matching your Raspberry Pi OS installation.

Docker^{↗ Bright Coding Blog} Compose Setup

# 1. Clone repository
git clone https://github.com/sipeed/picoclaw.git
cd picoclaw

# 2. First run — auto-generates docker/data/config.json then exits
#    (only triggers when both config.json and workspace/ are missing)
docker compose -f docker/docker-compose.yml --profile launcher up
# Container prints "First-run setup complete." and stops

# 3. Configure API keys
vim docker/data/config.json

# 4. Start services
docker compose -f docker/docker-compose.yml --profile launcher up -d
# Access at http://localhost:18800

Important for Docker/VM users: The Gateway listens on 127.0.0.1 by default. Set PICOCLAW_GATEWAY_HOST=0.0.0.0 or use the -public flag for external access.

Quick Start: WebUI Launcher

# Option 1: Double-click picoclaw-launcher (desktop)
# Option 2: Command line
picoclaw-launcher
# Opens browser at http://localhost:18800 automatically

For remote access, add -public:

picoclaw-launcher -public

Setup flow in WebUI: 1) Configure Provider (add LLM API key) → 2) Configure Channel (e.g., Telegram) → 3) Start Gateway → 4) Chat.

Android (APK)

Download from picoclaw.io/download—no Termux required for basic operation.

Real Code Examples

Basic Configuration: model_list with OpenAI

The model_list array defines available LLMs using protocol/model format. Here's the OpenAI example from the documentation:

{
  "model_list": [
    {
      "model_name": "gpt-5.4",
      "model": "openai/gpt-5.4"
    }
  ]
}

The model_name is your local alias; model specifies the provider and actual model identifier. API keys are loaded from .security.yml in version 1+ configs, keeping sensitive data out of config.json.

Local Ollama Deployment

For self-hosted models without API costs:

{
  "model_list": [
    {
      "model_name": "local-llama",
      "model": "ollama/llama3.1:8b",
      "api_base": "http://localhost:11434/v1"
    }
  ]
}

The api_base points to Ollama's OpenAI-compatible endpoint. No API key needed for local inference.

MCP Server Configuration

Extend agent capabilities with external tools via Model Context Protocol:

{
  "tools": {
    "mcp": {
      "enabled": true,
      "servers": {
        "filesystem": {
          "enabled": true,
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
        }
      }
    }
  }
}

This configures a filesystem MCP server with Node.js npx execution, scoped to /tmp for security.

CLI MCP Management

Instead of editing JSON, use the CLI:

# Add MCP server configuration
picoclaw mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /tmp

# List configured servers
picoclaw mcp list

# Test connectivity
picoclaw mcp test filesystem

The picoclaw mcp commands update config.json under tools.mcp.servers but do not manage server process lifecycle—configure your process manager separately for production deployments.

Terminal Configuration (Minimal Environments)

For headless or resource-constrained deployments without the WebUI:

# Initialize configuration and workspace
picoclaw onboard
# Creates ~/.picoclaw/config.json and workspace directory

Then edit ~/.picoclaw/config.json:

{
  "agents": {
    "defaults": {
      "model_name": "gpt-5.4"
    }
  },
  "model_list": [
    {
      "model_name": "gpt-5.4",
      "model": "openai/gpt-5.4"
    }
  ]
}

# One-shot query
picoclaw agent -m "What is 2+2?"

# Interactive mode
picoclaw agent

# Start gateway for chat app integration
picoclaw gateway

Advanced Usage & Best Practices

Security configuration: Version 1+ configs separate sensitive data into .security.yml. The project explicitly warns: do not deploy to production before v1.0 due to potential unresolved security issues. Review docs/security/security_configuration.md before handling credentials in production-like environments.

Resource monitoring: Recent builds may use 10-20MB RAM due to rapid PR merges. Track actual usage with picoclaw status and monitor for the planned post-stabilization optimization phase.

Gateway networking: Default 127.0.0.1:18790 is secure for local development but insufficient for Docker, VMs, or remote access. Always use -public or set PICOCLAW_GATEWAY_HOST=0.0.0.0 with appropriate firewall rules.

Model routing for cost control: Configure lightweight models (local Ollama, Groq's fast inference) for simple queries, reserving expensive API calls for complex reasoning. The rule-based router doesn't require code changes—just model_list configuration.

Hook and SubTurn architecture: For complex agent orchestration, review the docs/architecture/ guides on Hooks (event-driven observers and interceptors), Steering (message injection between tool calls), and SubTurn (subagent coordination). These are advanced features for developers building multi-agent systems.

Comparison with Alternatives

*Recent builds: 10-20MB. Optimization planned post-v1.0.

Trade-offs to consider: PicoClaw's extreme minimalism comes with ecosystem immaturity. OpenClaw has deeper integrations and a larger plugin ecosystem. NanoBot benefits from Python's ML-native libraries. PicoClaw wins where resource constraints are non-negotiable—embedded systems, old hardware, or cost-sensitive scale deployments. The Go ecosystem also means easier deployment (single binary, no interpreter) but potentially less access to Python's data science tooling for custom extensions.

FAQ

What hardware can actually run PicoClaw? Tested boards include LicheeRV-Nano ($9.90 RISC-V), Raspberry Pi Zero 2 W, various Android phones, and standard x86_64/ARM64 servers. See the Hardware Compatibility List for details.

Is there really no cryptocurrency or token? Correct. The project explicitly states: "PicoClaw has not issued any official tokens or cryptocurrency." Claims on pump.fun or trading platforms are scams. Only trust picoclaw.io and sipeed.com.

Can I use local models without API costs? Yes. Ollama and vLLM providers require no API keys. Configure api_base to your local endpoint.

What's the difference between the Launcher and core binary? The Launcher provides a web UI at localhost:18800. The core picoclaw binary handles agent logic, gateway, and CLI. The Launcher requires Node.js/pnpm to build; the core is pure Go.

How do I update without losing configuration? Configuration lives in ~/.picoclaw/ (or docker/data/ for Docker). Binary updates don't touch these directories. Use picoclaw migrate for version transitions.

Is v1.0 production-ready? The README explicitly warns: "Do not deploy to production before v1.0." Expect breaking changes and potential security issues in current releases.

What about Apple Silicon Macs? ARM64 builds run natively. macOS Gatekeeper may block the Launcher on first launch—use System Settings → Privacy & Security → Open Anyway.

Conclusion

sipeed/picoclaw occupies a genuinely distinct position in the AI agent landscape. Where most projects optimize for capability breadth, PicoClaw optimizes for deployment breadth—running meaningfully on hardware that other assistants cannot practically target. The 29,756 stars suggest this resonates with developers facing real constraints: edge deployments, cost-sensitive automation, hardware reuse, and privacy-conscious local inference.

The project is not without caveats. Pre-v1.0 status means API instability and acknowledged security gaps. The 10MB RAM claim needs verification against your specific use case—recent builds trend higher. And the AI-bootstrapped codebase, while impressive, may have architectural decisions that differ from conventionally engineered alternatives.

For Go developers, embedded systems engineers, home lab enthusiasts, and anyone who has looked at AI assistant deployment and balked at the infrastructure requirements, PicoClaw is worth serious evaluation. The single-binary deployment model, cross-architecture support, and growing provider/channel ecosystem provide a credible foundation.

Explore the code, test on your hardware, and contribute to the roadmap at https://github.com/sipeed/picoclaw.

For related reading on lightweight AI deployment strategies, see [INTERNAL_LINK: edge-ai-deployment-patterns].