Claw 生态02: PicoClaw - 在 $10 开发板上跑 AI Agent 的工程实现

如果你想在树莓派 Zero、老安卓手机、甚至 $10 的 RISC-V 开发板上跑 AI Agent，PicoClaw 是唯一的选择。

Sipeed（中国硬件公司）做的这个项目，用 Go 写的单二进制文件，内存占用小于 10MB，启动时间小于 1 秒。更夸张的是，95% 的代码是 LLM 生成的（AI 自举开发）。

GitHub 上 17.8k 星标，中文社区特别火，YouTube 上到处是"在 $10 板子上跑 OpenClaw 替代"的视频。

为什么需要 PicoClaw

OpenClaw 的问题很明确：太重了。

43 万行 TypeScript 代码，启动要好几秒，运行时内存占用超 1GB。这对 VPS 用户没问题，但对想在嵌入式设备上跑的人来说，就是不可能完成的任务。

PicoClaw 的目标是：在资源极度受限的硬件上，跑一个完整的 AI Agent。

结果是：
- 内存占用: <10MB（vs OpenClaw 的 1GB+）
- 启动时间: <1 秒（vs OpenClaw 的 3-5 秒）
- 二进制大小: 单文件 ~8MB（vs OpenClaw 的 node_modules 几百 MB）
- 支持硬件: $10 RISC-V/ARM 板、树莓派 Zero、老安卓手机（Termux）

Go 单二进制的优势

为什么选 Go？因为它天生适合嵌入式场景：

1. 单二进制部署：

# 编译
go build -o picoclaw main.go

# 部署（一个文件搞定）
scp picoclaw pi@raspberrypi:/usr/local/bin/

不需要 Node.js、Python 解释器、依赖包。一个文件，扔到设备上就能跑。

2. 交叉编译：

# 编译 ARM 版本（树莓派）
GOOS=linux GOARCH=arm GOARM=6 go build -o picoclaw-arm

# 编译 RISC-V 版本
GOOS=linux GOARCH=riscv64 go build -o picoclaw-riscv

# 编译 Android 版本（Termux）
GOOS=android GOARCH=arm64 go build -o picoclaw-android

一次编译，到处运行。

3. 内存占用低：

Go 的垃圾回收器针对低内存场景优化过。PicoClaw 在 512MB RAM 的设备上跑得很稳。

4. 并发性能好：

Go 的 goroutine 很轻（2KB 栈），适合处理多个聊天平台的并发连接。

架构设计

PicoClaw 的架构和 OpenClaw 类似，但做了大量优化：

picoclaw/
├── gateway/        # 聊天平台接入
│   ├── telegram.go
│   ├── discord.go
│   └── wechat.go
├── agent/          # Agent 核心
│   ├── loop.go     # ReAct 循环
│   ├── context.go  # 上下文管理
│   └── memory.go   # 记忆系统
├── tools/          # 工具集
│   ├── registry.go # 工具注册
│   ├── web.go
│   └── file.go
├── providers/      # LLM 提供商
│   ├── openai.go
│   └── anthropic.go
├── heartbeat/      # 心跳任务
└── workspace/      # 沙箱环境

1. Gateway - 轻量级接入

PicoClaw 的 gateway 用 Go 的标准库实现，没有额外依赖：

// gateway/telegram.go (简化版)
type TelegramGateway struct {
    token  string
    client *http.Client
}

func (g *TelegramGateway) Listen(callback func(string) string) {
    offset := 0
    for {
        // 轮询 Telegram API
        updates := g.getUpdates(offset)
        for _, update := range updates {
            message := update.Message.Text
            response := callback(message)  // 调用 agent
            g.sendMessage(update.Message.ChatID, response)
            offset = update.UpdateID + 1
        }
        time.Sleep(1 * time.Second)
    }
}

没有用第三方 SDK，直接调 HTTP API。这样二进制文件更小，依赖更少。

2. Agent Loop - 内存优化

PicoClaw 的 agent loop 做了大量内存优化：

// agent/loop.go (简化版)
func AgentLoop(input string, ctx *Context) string {
    // 限制上下文长度（避免内存爆炸）
    if len(ctx.Messages) > 20 {
        ctx.Messages = ctx.Messages[len(ctx.Messages)-20:]
    }

    for !done {
        // 构建 prompt
        prompt := buildPrompt(input, ctx)

        // 调用 LLM（流式响应，节省内存）
        stream := llm.GenerateStream(prompt)
        response := ""
        for chunk := range stream {
            response += chunk
        }

        // 解析响应
        if isToolCall(response) {
            result := executeTool(response)
            ctx.Append(result)
        } else {
            return response
        }
    }
}

关键优化：
- 限制上下文长度：超过 20 条消息就截断，避免内存爆炸
- 流式响应：不等 LLM 生成完整响应，边生成边处理，节省内存
- 及时释放：用完的对象立即释放，触发 GC

3. Memory - 文件系统存储

PicoClaw 的 memory 系统极简：

// agent/memory.go (简化版)
type Memory struct {
    workspace string
}

func (m *Memory) Save(content string) error {
    file := filepath.Join(m.workspace, "MEMORY.md")
    f, _ := os.OpenFile(file, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    defer f.Close()

    timestamp := time.Now().Format("2006-01-02 15:04:05")
    _, err := f.WriteString(fmt.Sprintf("\n## %s\n%s\n", timestamp, content))
    return err
}

func (m *Memory) Search(query string) (string, error) {
    file := filepath.Join(m.workspace, "MEMORY.md")
    cmd := exec.Command("grep", "-i", query, file)
    output, err := cmd.Output()
    return string(output), err
}

为什么不用数据库？因为：
- 文件系统更轻：不需要额外进程
- grep 够快：几千条记录，grep 毫秒级
- 易备份：直接复制文件夹

4. Workspace - 沙箱隔离

PicoClaw 默认把所有操作限制在 ~/.picoclaw/workspace：

// workspace/sandbox.go (简化版)
type Sandbox struct {
    root string
}

func (s *Sandbox) ValidatePath(path string) error {
    // 解析绝对路径
    absPath, _ := filepath.Abs(path)

    // 检查是否在 workspace 内
    if !strings.HasPrefix(absPath, s.root) {
        return fmt.Errorf("path outside workspace: %s", path)
    }
    return nil
}

func (s *Sandbox) ReadFile(path string) ([]byte, error) {
    if err := s.ValidatePath(path); err != nil {
        return nil, err
    }
    return os.ReadFile(path)
}

所有文件操作都要经过 ValidatePath 检查，防止越界访问。

5. Heartbeat - 定时任务

PicoClaw 支持心跳任务（每 30 分钟检查一次待办）：

// heartbeat/scheduler.go (简化版)
func StartHeartbeat(agent *Agent) {
    ticker := time.NewTicker(30 * time.Minute)
    defer ticker.Stop()

    for range ticker.C {
        // 读取 HEARTBEAT.md
        tasks := readHeartbeatFile()

        // 执行每个任务
        for _, task := range tasks {
            if task.ShouldRun() {
                result := agent.Execute(task.Prompt)
                logResult(task, result)
            }
        }
    }
}

HEARTBEAT.md 格式：

## Check emails
- Frequency: every 30 minutes
- Prompt: Check my emails and summarize important ones

## Daily summary
- Frequency: every day at 18:00
- Prompt: Summarize what I did today

内存优化技巧

PicoClaw 能在 10MB 内存下运行，靠的是这些技巧：

1. 避免大对象：

// 错误：一次性加载整个文件
content, _ := os.ReadFile("large.txt")  // 可能几百 MB

// 正确：流式读取
file, _ := os.Open("large.txt")
scanner := bufio.NewScanner(file)
for scanner.Scan() {
    line := scanner.Text()
    process(line)  // 逐行处理
}

2. 复用对象：

// 使用 sync.Pool 复用对象
var bufferPool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

func process() {
    buf := bufferPool.Get().(*bytes.Buffer)
    defer bufferPool.Put(buf)
    buf.Reset()
    // 使用 buf
}

3. 限制并发：

// 限制同时处理的请求数
semaphore := make(chan struct{}, 5)  // 最多 5 个并发

for _, req := range requests {
    semaphore <- struct{}{}  // 获取信号量
    go func(r Request) {
        defer func() { <-semaphore }()  // 释放信号量
        process(r)
    }(req)
}

实战：在树莓派 Zero 上部署

树莓派 Zero 的配置：
- CPU: 1GHz 单核 ARM
- RAM: 512MB
- 存储: 8GB SD 卡

1. 交叉编译：

# 在开发机上编译
GOOS=linux GOARCH=arm GOARM=6 go build -ldflags="-s -w" -o picoclaw-arm

# -ldflags="-s -w" 去掉调试信息，减小文件大小

2. 部署：

# 复制到树莓派
scp picoclaw-arm pi@raspberrypi:/home/pi/picoclaw

# SSH 登录
ssh pi@raspberrypi

# 添加执行权限
chmod +x picoclaw

# 配置
cat > config.json <<EOF
{
  "llm": {
    "provider": "openai",
    "api_key": "sk-xxx",
    "model": "gpt-4o-mini"
  },
  "channels": [
    {
      "type": "telegram",
      "token": "xxx"
    }
  ],
  "workspace": "/home/pi/.picoclaw/workspace"
}
EOF

# 运行
./picoclaw --config config.json

3. 性能测试：

# 启动时间
time ./picoclaw --version
# real    0m0.234s  (<1 秒)

# 内存占用
ps aux | grep picoclaw
# RSS: 8.2MB

# CPU 占用（空闲时）
top -p $(pidof picoclaw)
# %CPU: 0.3

在老安卓手机上跑

PicoClaw 支持 Termux（Android 终端模拟器）：

1. 安装 Termux：
- 从 F-Droid 下载 Termux
- 打开 Termux

2. 部署：

# 更新包管理器
pkg update && pkg upgrade

# 下载 PicoClaw（Android ARM64 版本）
wget https://github.com/sipeed/picoclaw/releases/download/v1.0/picoclaw-android-arm64
chmod +x picoclaw-android-arm64

# 配置
nano config.json
# （同上）

# 运行
./picoclaw-android-arm64 --config config.json

# 后台运行（关闭 Termux 后继续）
nohup ./picoclaw-android-arm64 --config config.json &

3. 开机自启：

# 安装 Termux:Boot
pkg install termux-services

# 创建启动脚本
mkdir -p ~/.termux/boot
cat > ~/.termux/boot/picoclaw.sh <<EOF
#!/data/data/com.termux/files/usr/bin/bash
cd /data/data/com.termux/files/home
./picoclaw-android-arm64 --config config.json &
EOF
chmod +x ~/.termux/boot/picoclaw.sh

与 OpenClaw 的对比

维度
OpenClaw
PicoClaw

代码量
43 万行
~1.5 万行

语言
TypeScript
Go

启动时间
3-5 秒
<1 秒

内存占用
>1GB
<10MB

二进制大小
node_modules 几百 MB
单文件 8MB

支持硬件
VPS/高配设备
$10 开发板/树莓派/老手机

部署复杂度
高（需要 Node.js）
低（单文件）

PicoClaw 砍掉了什么？

技能市场：没有在线市场（但可以手动添加工具）
Web UI：只有命令行
复杂插件系统：静态编译，不支持动态加载

但核心功能都在：gateway、agent loop、memory、tools、heartbeat、subagents。

适合谁

PicoClaw 适合：

嵌入式场景：树莓派、开发板、路由器
老设备复用：老手机、老笔记本
资源受限环境：低配 VPS、共享主机
离线场景：不想依赖云服务，本地运行

不适合：

需要 Web UI 的人：只有命令行
需要技能市场的人：没有在线市场
不熟悉 Go 的人：二次开发需要懂 Go

AI 自举开发

PicoClaw 的一个有趣点是：95% 的代码是 LLM 生成的。

Sipeed 团队的做法：

写核心架构（5%）：定义接口、模块划分
让 LLM 生成实现（95%）：用 Claude/GPT-4 生成具体代码
人工审查和优化：修复 bug、优化性能

这证明了：AI 可以写出生产级的代码，只要架构设计得好。

总结

PicoClaw 证明了：AI Agent 可以在 $10 的硬件上跑。

它用 Go 的单二进制部署、低内存占用、快速启动，把 OpenClaw 的核心功能搬到了嵌入式设备上。对于想在树莓派、老手机、开发板上跑 AI Agent 的人来说，这是唯一的选择。

更重要的是，它展示了一种新的开发模式：AI 自举开发 —— 用 AI 写 AI Agent 的代码。这可能是未来软件开发的方向。