MimiClaw: the AI ​​assistant that fits on a €5 chip

MimiClaw is one of those AI projects that seem like science fiction. Until you see it in action: an intelligent, always-on assistant running on a simple ESP32-S3 board that costs just a few euros, without Linux, Node.js, or the need for an external server. The entire agent infrastructure—memory, tools, cron, access to OpenAI or Anthropic models—lives inside a tiny chip powered by USB that literally fits in your pocket.

You send him a message via Telegram, The board receives the command via WiFi, passes it through an agent loop with tools, memory, and task schedulingAnd it responds as if you were talking to a high-end desktop assistant. But there's no €600 Mac mini behind it; instead, there's a microcontroller costing around €5, with local flash storage and an extremely optimized C architecture. It's the extreme version of the "Claw" movement. AI personal agents that can be run on virtually any device.

What is MimiClaw and why has it attracted so much attention

MimiClaw defines itself as the world's first AI assistant to run on a $5 chipInspired by OpenClaw and other projects in the family such as NanoClaw, PicoClaw, and ZeroClaw, but taken to the realm of embedded hardware. Its objective is clear: to demonstrate that you can have a complete personal agent, with tools and persistent memory, in an environment without a traditional operating system.

MimiClaw's heart is a ESP32-S3 board with 16 MB of flash and 8 MB of PSRAMThis is sufficient to host the firmware, the SPIFFS file system, and all the agent's configuration files and memory. Instead of running containers, daemons, or background services, everything is implemented in pure C on top of the Espressif SDK, which drastically reduces resource consumption.

In terms of user experience, The process is as simple as plugging in the board via USB, connecting it to WiFi, and talking to it via Telegram.The assistant listens through a Telegram bot, passes the messages to a language model (Anthropic Claude or OpenAI GPT(hot-configurable) and can chain tool calls, read and write files in local memory, and schedule future tasks. All the "smart" part happens in the agent loop, which follows a ReAct (reasoning + action) pattern to iteratively solve tasks.

In terms of power consumption, MimiClaw is designed to be switched on permanently: It operates at approximately 0,5W from a simple USB port.This opens the door to having assistants embedded in routers, IP cameras, small home servers, or even makeshift devices you have around the house.

The project is licensed under MITThis allows for the reuse, modification, and adaptation of the code with considerable freedom. This perfectly aligns with the spirit of the Claw ecosystem: open, auditable, and easily forked personal agents that can be adapted to each use case.

Hardware and basic requirements to get MimiClaw up and running

To set up your own assistant with MimiClaw you don't need a lab, but you do need to meet certain minimum hardware requirements and have access to APIs. The list of components is surprisingly shortespecially if you come from the OpenClaw desktop world.

Regarding the plate, An ESP32-S3 with 16 MB of flash and 8 MB of PSRAM is explicitly recommended.For example, a Xiaozhi AI board or similar, which usually cost around €10. There are other ESP32-S3 variants, but if you're short on memory, you'll end up struggling with firmware space and the file system.

In addition to the plate, You will need a USB-C cable that allows you to both power the device and flash firmware And, optionally, open a serial console for debugging or hot-swapping. Many models have two separate USB-C ports, which can lead to some confusion when plugging them in.

At the level of external services, At least one LLM provider and one messaging channel are needed.MimiClaw supports both Anthropic (Claude) and other models, switchable at runtime, so you can change providers or models without recompiling. A Telegram bot, created via @BotFather, is used to communicate with the assistant and provides the necessary access token.

If you want to activate extra features such as web search using Brave SearchYou'll also need to obtain a Brave API key and declare it in the project's secrets settings. All of this is managed using constants and values ​​that can then be overridden via the CLI on the device itself.

Development and installation environment on Ubuntu and macOS

Although MimiClaw runs on the ESP32-S3, The firmware is compiled in a desktop development environment., generally Ubuntu or macOS, using the Espressif toolchain (ESP-IDF) and standard utilities such as CMake and Ninja.

In the case of Ubuntu, it is recommended to work with versions 22.04 or 24.04With Python 3.10 or higher and CMake 3.16 or higher. Ninja (>= 1.10), Git (>= 2.34), flex (>= 2.6), bison (>= 3.8), gperf (>= 3.1), and dfu-util (>= 0.11) are also required. At the system library level, classic dependencies such as libusb-1.0-0, libffi-dev and libssl-devwhich allow managing device flashing and cryptographic functions related to TLS.

On macOS, The recommended base is macOS 12, 13 or 14 with Xcode Command Line Tools installed and Homebrew as the package manager. As with Linux, Python 3.10 or higher, CMake, Ninja, Git, flex, bison, gperf, dfu-util, and libraries such as libusb, libffi and opensslWith Homebrew, installing this environment is quite straightforward, although you have to keep an eye on the library paths so that ESP-IDF detects them without problems.

Once the environment is set up, The usual sequence is to clone the repository, adjust the secrets, and launch the build.The key file here is main/mimi_secrets.hThis file defines the default configuration values: Telegram tokens, Anthropic or OpenAI keys, network parameters, etc. After editing this file, the firmware is compiled and flashed to the board using ESP-IDF tools.

An important detail that often causes confusion: Many ESP32-S3 boards have two USB-C ports.One labeled “USB” or “USB/JTAG” and the other “COM”, “UART”, or similar. To flash the firmware with idf.py flash You must use the native USB/JTAG port, while the REPL console is controlled via the UART/COM port. If you connect the cable to the wrong connector, the flashing process will usually fail, or you won't see the serial monitor.

MimiClaw configuration: two-tier system and runtime CLI

Once the firmware is on the board, MimiClaw is configured using a two-layer systemOn one hand, there are the compilation values ​​defined in mimi_secrets.hOn the other hand, there are the settings changed at runtime via the serial CLI, which are stored in NVS (the ESP32 configuration memory) and take precedence over the default values.

This means that even if you have set the Telegram token or the Anthropic API key in the headers, You can modify them later without recompiling.Simply connect a USB cable to the serial port, open a terminal, and use the built-in configuration commands. This is a very practical way to adjust the wizard's behavior when it's deployed away from your development team.

Access to the CLI is through the port labeled “COM” or “UART”, which is usually connected to a USB-serial bridge such as CP2102 or CH340. The ESP-IDF REPL console is mapped to that UART port by default., something that is controlled with the option CONFIG_ESP_CONSOLE_UART_DEFAULT=y in the project settings. If you connect both ports at the same time, the USB/JTAG handles flashing and a secondary serial channel, while the UART provides the main interactive console.

On macOS systems, devices typically appear as /dev/cu.usbmodem* o /dev/cu.usbserial-*Therefore, it is advisable to list with ls /dev/cu.usb* to know which is which. In Linux the typical convention is /dev/ttyACM0 for USB/JTAG and /dev/ttyUSB0 for UART/COM. Once you have identified the correct port, you can open the session with screen, minicom or the ESP-IDF monitor.

From that console, Configuration commands allow you to tweak sensitive parameters without touching the source code.Change API keys, redefine the default provider (Claude or OpenAI), adjust heartbeat intervals, or modify network settings. Every change is saved to NVS and persists even if you reboot or repower the board.

Internal architecture, “soul” files, and persistent memory

One of the unique features of MimiClaw is how it manages the assistant's identity and memory. Instead of hiding everything in an opaque database, use plain text files in a flash file system (SPIFFS) that can be read and edited directly.

The typical structure includes files such as SOUL.md, USER.md, MEMORY.md o HEARTBEAT.mdin addition to history files and task scheduling. Each one fulfills a specific role within the agent loop and is integrated into the prompts sent to the language model.

• SOUL.mdThis defines the assistant's personality, tone, working style, and basic principles. By changing this file, you can transform MimiClaw into a serious agent, a development co-pilot, a task manager, or a more conversational assistant.
• USER.mdThis contains information about the user: name, preferred language, habits, personal or professional context. This allows for more personalized responses and helps the assistant better understand "who" it is talking to.
• MEMORY.mdIt acts as long-term memory, storing facts that the agent should always remember. Unlike a pure history file, this file is consulted repeatedly to maintain continuity between sessions.
• HEARTBEAT.mdA list of tasks periodically reviewed by the agent's "heartbeat" system. This is where pending tasks are written that the assistant must tackle autonomously in each cycle.
• cron.json: JSON file that stores the jobs scheduled by the agent itself, both recurring and one-time.
• Daily files and logs , the 2026-02-05.md o tg_12345.jsonl, which collect daily notes and the history of conversations via Telegram.

With this design, Anyone can directly modify MimiClaw's "psychology" and memory by editing text fileswithout needing to touch the C code. It's a very transparent and useful approach for experimenting with personalities, behavior rules, or long-term workflows.

All this content is persisted in the board's flash memory, so The memory remains after shutdowns, restarts, or OTA updatesIn this way, the assistant maintains real continuity with the user, even if the hardware is extremely limited in RAM.

Tools, function calls, and the ReAct pattern in MimiClaw

On the “cognitive” level, MimiClaw is not limited to chatting. The agent is able to invoke external tools through the function calling capabilities of Anthropic and OpenAIorganizing their own workflow until completing a complex task.

The pattern it follows is that of ReAct (Reason + Act)The model reasons about the objective, decides which tool to use, executes the call, analyzes the response, and, if necessary, chains together more actions. This loop repeats until a satisfactory result is achieved, at which point the assistant returns a final response to the user via Telegram or the channel they are using.

Among the tools integrated into MimiClaw, several stand out as particularly useful in an embedded environment:

• web_search: performs web searches through the Brave Search API, allowing you to obtain up-to-date information even from a microcontroller.
• get_current_time: checks the current date and time via HTTP and updates the system clock, which is key for scheduling tasks and logging events.
• cron_add: creates scheduled tasks, both recurring (every N seconds) and one-time execution (specific UNIX timestamp), which are saved in MimiClaw's own cron.
• cron_list y cron_remove: allow listing and deleting scheduled jobs by ID, so that the assistant can audit and clean up their own schedule.

To activate web search, The Brave Search key needs to be defined. in the secret MIMI_SECRET_SEARCH_KEY within mimi_secrets.h or via the configuration CLI. This allows the agent to use this tool when the prompt requires it, for example, to check news, documentation, or real-time service statuses.

Thanks to this combination of basic tools, MimiClaw behaves like a truly autonomous assistantcapable of gathering information, scheduling future events, and maintaining a structured file-based memory, all while coordinating with a cloud-hosted LLM provider.

Internal Cron and Heartbeat service: MimiClaw as a proactive agent

A distinguishing feature of this project is that The assistant doesn't wait for you to write to it.It has a cron system and a heartbeat mechanism that allow it to "wake up" periodically and act on its own.

The integrated cron works like a small calendar of automated tasks. Anthropic or OpenAI models can create scheduled jobs by calling the tool cron_adddefining both the cadence (at regular intervals) and individual executions. These jobs are stored in the file cron.json on SPIFFS and survive motherboard reboots.

When a job is triggered, A message is injected into the agent loopIt's treated as if it were a new prompt from the user, but generated internally by the system itself. The wizard processes this input, applies its rules, consults its memory files, and, if necessary, sends a notification to the user through the configured channel.

Related to this, MimiClaw integrates a heartbeat service that periodically examines the archive HEARTBEAT.mdEach time a heartbeat occurs (at a default interval of around 30 minutes), the system analyzes the file's contents to detect incomplete tasks: any line that is not a header, a blank line, or an item marked as - It is considered an outstanding issue.

If open tasks are found, A prompt is sent to the agent to review those inputs and act accordingly.It can update a task's status, send a summary, schedule a cron reminder, or perform an external action necessary to complete what's indicated in the heartbeat. In this way, MimiClaw goes from being merely reactive to behaving as a proactive assistant, capable of monitoring your lists and taking the initiative.

Advanced connectivity: WebSocket, OTA, HTTP proxy and dual core

Although the most visible interaction is through Telegram, MimiClaw incorporates several network capabilities that give it more flexibility in advanced scenarios. One of the key components is the WebSocket gateway integrated into the firmware., accessible on port 18789 of the local network.

With this gateway, You can connect any WebSocket client from your LAN to exchange messages with the assistant.Monitor its status, integrate custom dashboards, or link it with other homebrew applications without going through Telegram. It's especially useful in environments where you want a direct channel between the microcontroller and a local control system or dashboard.

Another very practical component is the OTA (Over-The-Air) update systemThis feature allows you to flash new firmware over the Wi-Fi network without having to reconnect USB cables. This is essential when you have MimiClaw embedded in hard-to-reach places, such as inside an electrical panel, attached to a router, or in a sealed enclosure.

In more complex network contexts, MimiClaw can also work with a HTTP proxy with CONNECT tunnel supportThis makes it easy to use in corporate environments with filters, strict firewalls, or mandatory proxies. The wizard adapts to these types of infrastructures without requiring a complete network reconfiguration.

All of this is supported by the dual-core architecture of the ESP32-S3. A core can be primarily dedicated to network I/O and system servicesOne handles agent processing, memory management, and coordination with the remote LLM, while the other manages the agent. This separation improves responsiveness and reduces deadlocks, which is crucial when you're pushing a microcontroller to its limits.

MimiClaw within the Claw ecosystem and the ultra-lightweight AI trend

MimiClaw does not appear in the void. It is part of a wave of projects inspired by OpenClaw, which started as a high-end personal agent (requiring around 1,5 GB of RAM and a Mac mini costing around €600 as a base) and has generated an ecosystem of increasingly efficient forks and reimplementations.

In just a few weeks, the community has produced variants such as NanoClaw, PicoClaw, ZeroClaw, IronClaw, TinyClaw, or sister implementations like NanobotEach explores a different aspect of the design space: code size, programming language, security, portability, hardware cost, or multi-agent experience. The journey has ranged from desktop configurations to €10 RISC-V platforms and, finally, to €5 microcontrollers like the MimiClaw ESP32.

Nanobot, for example, It focuses on clarity and minimalismWith around 4.000 lines of Python, NanoClaw is ideal for academic research or R&D environments. Written in TypeScript, it aims to be small enough to be understood in just a few minutes and integrates seamlessly with Linux containers and agent swarms.

IronClaw reinforces the angle of the "By design" security with Rust and WASM sandboxingThinking about sectors where a malicious agent would be a serious problem, ZeroClaw explores the path of extreme performance, with less than 5 MB of RAM and boot times in milliseconds, ideal for pushing AI to the absolute limits of available hardware.

PicoClaw, for his part, It reimplements agent logic in Go and brings it to cheap devices and even old Android phones.With startup times around one second and very low power consumption, TinyClaw is committed to a multi-agent and multi-team approach, geared towards collaborative environments where different agents assist various members of an organization.

Amidst this range, MimiClaw is at the extreme end of miniaturizationThe same concept of a personal agent, tools, and structured memory, but embedded in a microcontroller with pure C and negligible power consumption. This whole movement is reminiscent of the classic "Can it run DOOM?" question that the tech community used to ask of any device with a screen; now the question is morphing into "Can it run Claw?"

The moral is clear: Personal AI agents are ceasing to be a technology exclusive to powerful servers to expand to routers, cameras, older mobile phones, or circuit boards that just a few years ago were only used for hobby projects. What sounds futuristic today will soon be as commonplace as having Wi-Fi at home.

Taken together, MimiClaw encapsulates the philosophy of this new generation of assistants: Open source, executable on ridiculously cheap hardware, with readable local memory, real tools, task scheduling, and sufficiently powerful networking options so that it can be integrated into your daily life. If you're interested in taking AI beyond the cloud and putting it into physical devices, it's one of the most exciting projects to experiment with.