如果你觉得树莓派还是太贵、太大、太耗电，MimiClaw 会让你震惊：在 $5 的 ESP32-S3 芯片上跑 AI Agent。
没有 Linux，没有 OS，没有 Node/Python 解释器。纯 C 代码，直接跑在裸金属上。0.5W USB 供电，Telegram 接口，本地 flash 存储，OTA 更新，心跳任务，工具调用。
GitHub 上 2.9k 星标，Twitter 上惊叹帖很多："OpenClaw on $5 芯片""最便携隐私版"。极客圈爆火。
为什么需要 MimiClaw
OpenClaw 的问题：太重了。
即使是 PicoClaw（Go，<10MB 内存），也需要 Linux 系统、至少 512MB RAM、几百 MHz CPU。对于想在真正的嵌入式设备上跑的人来说，还是不够。
MimiClaw 的目标：在最便宜、最小、最省电的硬件上，跑一个完整的 AI Agent。
结果：
- 硬件: ESP32-S3（$5 芯片）
- 功耗: 0.5W（USB 供电）
- 内存: 512KB SRAM + 8MB Flash
- 尺寸: 25mm x 18mm（比硬币还小）
- 系统: 无 OS（裸金属）
ESP32-S3 是什么
ESP32-S3 是乐鑫（Espressif）出的一款 WiFi + BLE 芯片：
规格：
- CPU: 双核 Xtensa LX7，240MHz
- RAM: 512KB SRAM
- Flash: 8MB（外置）
- WiFi: 802.11 b/g/n
- BLE: Bluetooth 5.0
- 功耗: 0.5W（活跃）/ 10μA（深度睡眠）
- 价格: $5（单片）
为什么选 ESP32-S3：
- 便宜：$5 就能买到完整的 WiFi + BLE 芯片
- 省电：0.5W 活跃功耗，可以用电池供电
- 小巧：25mm x 18mm，可以嵌入任何设备
- 成熟：Arduino/ESP-IDF 生态完善
架构设计
MimiClaw 的架构和 OpenClaw 类似，但做了大量裁剪：
MimiClaw (ESP32-S3)
├── main.c # 主循环
├── gateway/ # Telegram 接口
│ └── telegram.c
├── agent/ # Agent 核心
│ ├── loop.c # ReAct 循环
│ └── memory.c # SPIFFS 存储
├── tools/ # 工具集
│ ├── web_search.c
│ └── weather.c
├── llm/ # LLM 调用
│ └── openai.c
└── heartbeat/ # 心跳任务
└── scheduler.c
1. 无 OS 架构
MimiClaw 不用 FreeRTOS，直接跑在裸金属上：
// main.c (简化版)
void app_main(void) {
// 初始化 WiFi
wifi_init();
// 初始化 SPIFFS（文件系统）
spiffs_init();
// 加载配置
load_config();
// 启动双核任务
xTaskCreatePinnedToCore(network_task, "network", 4096, NULL, 1, NULL, 0); // 核心 0
xTaskCreatePinnedToCore(agent_task, "agent", 8192, NULL, 1, NULL, 1); // 核心 1
// 主循环（空闲）
while (1) {
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}
双核分离：
- 核心 0：处理网络（WiFi、Telegram API）
- 核心 1：处理 AI 逻辑（agent loop、工具调用）
这样网络和 AI 不会互相阻塞。
2. SPIFFS 文件系统
ESP32-S3 的 Flash 用 SPIFFS（SPI Flash File System）管理：
// agent/memory.c (简化版)
#include "esp_spiffs.h"
void memory_init(void) {
esp_vfs_spiffs_conf_t conf = {
.base_path = "/spiffs",
.partition_label = NULL,
.max_files = 5,
.format_if_mount_failed = true
};
esp_vfs_spiffs_register(&conf);
}
void memory_save(const char* content) {
FILE* f = fopen("/spiffs/MEMORY.md", "a");
if (f) {
fprintf(f, "\n## %ld\n%s\n", time(NULL), content);
fclose(f);
}
}
char* memory_search(const char* query) {
FILE* f = fopen("/spiffs/MEMORY.md", "r");
if (!f) return NULL;
static char result[1024];
char line[256];
result[0] = '\0';
// 简单的字符串匹配
while (fgets(line, sizeof(line), f)) {
if (strstr(line, query)) {
strcat(result, line);
}
}
fclose(f);
return result;
}
SPIFFS 的文件：
- /spiffs/SOUL.md - Agent 的身份和目标
- /spiffs/MEMORY.md - 长期记忆
- /spiffs/HEARTBEAT.md - 心跳任务
- /spiffs/cron.json - 定时任务配置
3. Telegram Gateway
MimiClaw 用 Telegram Bot API 接收消息：
// gateway/telegram.c (简化版)
#include "esp_http_client.h"
#define TELEGRAM_API "https://api.telegram.org/bot"
void telegram_listen(void (*callback)(const char*)) {
int offset = 0;
while (1) {
// 构建 URL
char url[256];
snprintf(url, sizeof(url), "%s%s/getUpdates?offset=%d&timeout=30",
TELEGRAM_API, bot_token, offset);
// 发送 HTTP 请求
esp_http_client_config_t config = {.url = url};
esp_http_client_handle_t client = esp_http_client_init(&config);
esp_http_client_perform(client);
// 解析响应（简化版，实际需要 JSON 解析）
char* response = get_response_body(client);
if (response) {
// 提取消息
char* message = extract_message(response);
if (message) {
// 调用 agent
char* reply = callback(message);
// 发送回复
telegram_send(chat_id, reply);
// 更新 offset
offset = extract_update_id(response) + 1;
}
}
esp_http_client_cleanup(client);
vTaskDelay(1000 / portTICK_PERIOD_MS);
}
}
4. Agent Loop
MimiClaw 的 agent loop 是纯 C 实现的 ReAct：
// agent/loop.c (简化版)
char* agent_loop(const char* input) {
static char context[2048];
static char response[1024];
// 加载 SOUL.md
char* soul = read_file("/spiffs/SOUL.md");
// 构建 prompt
snprintf(context, sizeof(context),
"%s\n\nUser: %s\n\nYou have these tools: web_search, weather\n",
soul, input);
int max_iterations = 5;
for (int i = 0; i < max_iterations; i++) {
// 调用 LLM
llm_generate(context, response, sizeof(response));
// 检查是否是工具调用
if (strstr(response, "TOOL:")) {
// 解析工具名和参数
char tool_name[32], tool_args[256];
sscanf(response, "TOOL:%s ARGS:%s", tool_name, tool_args);
// 执行工具
char tool_result[512];
execute_tool(tool_name, tool_args, tool_result, sizeof(tool_result));
// 添加到上下文
strncat(context, "\nTool result: ", sizeof(context) - strlen(context) - 1);
strncat(context, tool_result, sizeof(context) - strlen(context) - 1);
} else {
// 最终回复
return response;
}
}
return "Max iterations reached";
}
5. LLM 调用
MimiClaw 通过 HTTPS 调用 OpenAI API：
// llm/openai.c (简化版)
#include "esp_http_client.h"
#include "cJSON.h"
void llm_generate(const char* prompt, char* output, size_t output_size) {
// 构建 JSON 请求
cJSON* root = cJSON_CreateObject();
cJSON_AddStringToObject(root, "model", "gpt-4o-mini");
cJSON_AddNumberToObject(root, "max_tokens", 500);
cJSON* messages = cJSON_CreateArray();
cJSON* message = cJSON_CreateObject();
cJSON_AddStringToObject(message, "role", "user");
cJSON_AddStringToObject(message, "content", prompt);
cJSON_AddItemToArray(messages, message);
cJSON_AddItemToObject(root, "messages", messages);
char* json_str = cJSON_Print(root);
// 发送 HTTP 请求
esp_http_client_config_t config = {
.url = "https://api.openai.com/v1/chat/completions",
.method = HTTP_METHOD_POST,
};
esp_http_client_handle_t client = esp_http_client_init(&config);
esp_http_client_set_header(client, "Content-Type", "application/json");
esp_http_client_set_header(client, "Authorization", api_key);
esp_http_client_set_post_field(client, json_str, strlen(json_str));
esp_http_client_perform(client);
// 解析响应
char* response = get_response_body(client);
cJSON* response_json = cJSON_Parse(response);
cJSON* content = cJSON_GetObjectItem(
cJSON_GetArrayItem(
cJSON_GetObjectItem(response_json, "choices"), 0
), "message"
);
strncpy(output, cJSON_GetObjectItem(content, "content")->valuestring, output_size);
// 清理
cJSON_Delete(root);
cJSON_Delete(response_json);
esp_http_client_cleanup(client);
}
6. Heartbeat 任务
MimiClaw 支持心跳任务（每 30 分钟检查一次）：
// heartbeat/scheduler.c (简化版)
void heartbeat_task(void* arg) {
while (1) {
// 读取 HEARTBEAT.md
char* tasks = read_file("/spiffs/HEARTBEAT.md");
// 解析任务（简化版）
char* line = strtok(tasks, "\n");
while (line) {
if (strstr(line, "## ")) {
// 提取任务 prompt
char* prompt = line + 3;
// 执行 agent
char* result = agent_loop(prompt);
// 记录日志
log_heartbeat(prompt, result);
}
line = strtok(NULL, "\n");
}
// 等待 30 分钟
vTaskDelay(30 * 60 * 1000 / portTICK_PERIOD_MS);
}
}
内存优化
ESP32-S3 只有 512KB SRAM，必须极致优化：
1. 静态分配：
// 错误：动态分配（可能碎片化）
char* buffer = malloc(1024);
// 正确：静态分配
static char buffer[1024];
2. 复用 buffer：
// 全局 buffer，所有函数复用
static char g_buffer[2048];
void func1() {
// 使用 g_buffer
snprintf(g_buffer, sizeof(g_buffer), "...");
}
void func2() {
// 复用 g_buffer（确保 func1 已完成）
snprintf(g_buffer, sizeof(g_buffer), "...");
}
3. 流式处理：
// 错误：一次性加载整个文件
char* content = read_entire_file("/spiffs/MEMORY.md"); // 可能几百 KB
// 正确：逐行读取
FILE* f = fopen("/spiffs/MEMORY.md", "r");
char line[256];
while (fgets(line, sizeof(line), f)) {
process_line(line);
}
fclose(f);
4. 压缩数据：
// 用 gzip 压缩存储
#include "miniz.h"
void save_compressed(const char* data) {
size_t compressed_size;
void* compressed = tdefl_compress_mem_to_heap(data, strlen(data), &compressed_size, 0);
write_file("/spiffs/data.gz", compressed, compressed_size);
free(compressed);
}
功耗优化
MimiClaw 可以用电池供电，需要优化功耗：
1. WiFi 省电模式：
// 启用 WiFi 省电
esp_wifi_set_ps(WIFI_PS_MIN_MODEM); // 最小功耗模式
2. 深度睡眠：
// 空闲时进入深度睡眠
void idle_sleep(void) {
// 设置唤醒源（定时器）
esp_sleep_enable_timer_wakeup(30 * 60 * 1000000); // 30 分钟
// 进入深度睡眠
esp_deep_sleep_start();
}
3. CPU 降频：
// 空闲时降低 CPU 频率
esp_pm_config_esp32s3_t pm_config = {
.max_freq_mhz = 240,
.min_freq_mhz = 80, // 空闲时降到 80MHz
.light_sleep_enable = true
};
esp_pm_configure(&pm_config);
OTA 更新
MimiClaw 支持 OTA（Over-The-Air）更新：
// ota/update.c (简化版)
#include "esp_ota_ops.h"
void ota_update(const char* url) {
esp_http_client_config_t config = {.url = url};
esp_http_client_handle_t client = esp_http_client_init(&config);
// 获取 OTA 分区
const esp_partition_t* update_partition = esp_ota_get_next_update_partition(NULL);
esp_ota_handle_t ota_handle;
esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &ota_handle);
// 下载并写入
char buffer[1024];
int len;
while ((len = esp_http_client_read(client, buffer, sizeof(buffer))) > 0) {
esp_ota_write(ota_handle, buffer, len);
}
// 完成更新
esp_ota_end(ota_handle);
esp_ota_set_boot_partition(update_partition);
// 重启
esp_restart();
}
实战：部署到 ESP32-S3
1. 硬件准备：
- ESP32-S3 开发板（$10，含 USB 接口）
- USB 数据线
- WiFi 网络
2. 安装 ESP-IDF：
# 安装依赖
sudo apt-get install git wget flex bison gperf python3 python3-pip cmake ninja-build
# 下载 ESP-IDF
git clone --recursive https://github.com/espressif/esp-idf.git
cd esp-idf
./install.sh esp32s3
# 设置环境变量
. ./export.sh
3. 编译 MimiClaw：
# 克隆 MimiClaw
git clone https://github.com/memovai/mimiclaw.git
cd mimiclaw
# 配置
idf.py menuconfig
# 设置 WiFi SSID/密码、Telegram token、OpenAI API key
# 编译
idf.py build
4. 烧录：
# 连接 ESP32-S3 到电脑
# 烧录固件
idf.py -p /dev/ttyUSB0 flash
# 查看日志
idf.py -p /dev/ttyUSB0 monitor
5. 测试：
# 在 Telegram 上给 bot 发消息
User: What's the weather in Beijing?
# ESP32-S3 日志
I (12345) mimiclaw: Received message: What's the weather in Beijing?
I (12346) mimiclaw: Calling tool: weather(city=Beijing)
I (12789) mimiclaw: Tool result: 5°C, Cloudy
I (12790) mimiclaw: Sending reply: The weather in Beijing is 5°C and cloudy.
性能测试
实测（ESP32-S3，240MHz，512KB RAM）：
启动时间: 2.3 秒（包括 WiFi 连接）
内存占用:
- 代码: 180KB
- 堆: 120KB
- 栈: 32KB
- 总计: 332KB / 512KB（剩余 180KB）
响应时间:
- Telegram 接收消息: 50ms
- Agent loop（无工具调用）: 1.2s（LLM 调用）
- Agent loop（有工具调用）: 2.5s
- Telegram 发送回复: 80ms
功耗:
- 活跃（WiFi on）: 0.5W
- 空闲（WiFi on）: 0.3W
- 深度睡眠: 10μA（可忽略）
电池续航（2000mAh）:
- 持续活跃: 8 小时
- 间歇使用（每小时 5 分钟）: 3 天
与其他方案的对比
维度
MimiClaw
PicoClaw
nanobot
硬件
ESP32-S3 ($5)
树莓派 Zero ($10)
VPS/PC
系统
无 OS
Linux
Linux
内存
512KB
512MB
1GB+
功耗
0.5W
2W
10W+
尺寸
25mm x 18mm
65mm x 30mm
N/A
电池供电
是
困难
否
MimiClaw 是最小、最便宜、最省电的方案。
适合谁
MimiClaw 适合：
- 极客：想在最小的硬件上跑 AI Agent
- IoT 场景：需要嵌入到设备中（智能家居、可穿戴）
- 离线场景：不想依赖云服务，本地运行
- 便携场景：需要电池供电、随身携带
- 隐私场景：所有数据存在本地 Flash
不适合：
- 不熟悉嵌入式的人：需要懂 C、ESP-IDF
- 需要复杂功能的人：MimiClaw 功能有限
- 需要大内存的人：只有 512KB SRAM
总结
MimiClaw 证明了：AI Agent 可以在 $5 的芯片上跑。
它用纯 C 代码、无 OS、SPIFFS 文件系统、双核分离、极致内存优化，把 OpenClaw 的核心功能搬到了 ESP32-S3 上。对于想在最小、最便宜、最省电的硬件上跑 AI Agent 的人来说，这是唯一的选择。
更重要的是，它展示了嵌入式 AI 的可能性：AI Agent 不需要云端，不需要 VPS，甚至不需要 Linux。一个 $5 的芯片，就能让你的设备拥有 AI 能力。
相关链接：
- MimiClaw GitHub
- ← 上一篇：TinyClaw - 用 400 行 Shell 实现多代理协作
- ← 返回系列总览