How to Run an OpenClaw-Style Agent on Raspberry Pi Pico 2

Sipeed's PicoClaw runs a full AI agent assistant on hardware with under 10MB of RAM, 99% less than a standard OpenClaw installation. But PicoClaw is a Go binary that requires Linux. The Raspberry Pi Pico 2 W, a $7 microcontroller with 520KB of SRAM and built-in WiFi, runs MicroPython on bare metal with no operating system at all. That makes it one of the cheapest platforms available for AI agent orchestration at the network edge.

The Pico 2 launched in August 2024 with the RP2350 chip, and the WiFi-equipped Pico 2 W followed in November 2024. Here is what changed from the original Pico W:

Raspberry Pi Pico W (RP2040)

• Dual Cortex-M0+ at 133MHz
• 264KB SRAM, 2MB flash
• WiFi 802.11n, Bluetooth 5.0
• No hardware FPU
• $6

Raspberry Pi Pico 2 (RP2350, no WiFi)

• Dual Cortex-M33 or Hazard3 RISC-V at 150MHz
• 520KB SRAM, 4MB flash
• Hardware FPU, ARM TrustZone, signed boot, hardware TRNG
• No wireless connectivity
• $5

Raspberry Pi Pico 2 W (RP2350 with WiFi)

• Same RP2350 chip plus WiFi 802.11n, Bluetooth 5.2
• WPA3 security support
• $7

For agent workloads, the meaningful upgrades are doubled SRAM for buffering larger API responses, a hardware FPU for faster JSON parsing, TrustZone for storing API credentials securely, and doubled flash for holding more skill modules. The Cortex-M33 architecture also delivers higher instruction throughput than the M0+ cores in the original Pico, along with a clock speed bump from 133MHz to 150MHz.

The distinction between "AI on a microcontroller" and "AI agent orchestration from a microcontroller" matters. TinyML projects run small, pre-trained models (classifiers, anomaly detectors) directly on MCU hardware. Agent orchestration is different. The microcontroller runs no model at all. It acts as a client that sends prompts to cloud LLMs and executes the responses locally.

The pattern follows a repeating loop:

1. Sense: Read inputs from GPIO pins, I2C sensors, SPI devices, or incoming network data.
2. Prompt: Format a request that includes sensor readings, context, and available tools, then send it to a cloud LLM endpoint over WiFi.
3. Think: The cloud LLM (Claude, GPT, Gemini, or others) processes the prompt and returns a response, sometimes with tool-call instructions.
4. Act: The Pico 2 W parses the response and executes actions: toggling a relay, writing a log entry, sending an HTTP POST to another service, or triggering a buzzer.

This loop runs continuously, with the MCU handling all I/O and networking while the cloud handles all reasoning. The pico-claw-micropython project implements exactly this pattern on the original Pico W.

The hardware constraints shape what you can build. 520KB of SRAM means you cannot buffer long conversation histories, so context must be truncated between iterations. MicroPython on the RP2350 uses cooperative multitasking, so long-running LLM API calls block other operations. Each cloud call adds 200ms to several seconds of latency depending on prompt length. And WiFi transmission draws significant current, so battery-powered agents need sleep modes between calls.

Three projects occupy different points on the spectrum from full-featured agent framework to bare-metal microcontroller code.

OpenClaw is the full agent framework with over 250,000 GitHub stars as of May 2026. It connects LLMs to execution surfaces including shell commands, file systems, browser automation, and messaging platforms. It runs on macOS, Linux, and Windows with full operating system access. The skills ecosystem on ClawHub lists over 3,200 community-built extensions. OpenClaw requires far too many system resources for a microcontroller, but its architecture (the skills pattern and tool-use loop) inspired lighter implementations.

PicoClaw (sipeed/picoclaw) is a Go binary with over 29,000 GitHub stars that compresses the agent concept into a single executable using under 10MB of RAM. It boots in under one second on hardware like the Raspberry Pi Zero 2 W or Sipeed's LicheeRV-Nano. Despite the "Pico" in its name, PicoClaw still requires a Linux operating system. It supports RISC-V, ARM, MIPS, and x86_64 architectures and integrates with over 30 LLM providers.

pico-claw-micropython is an early-stage project that brings the agent orchestration pattern to the Raspberry Pi Pico W. Written in MicroPython, it implements the sense-prompt-think-act loop where the Pico W calls cloud LLM APIs (Claude, GPT, or Kimi-K2) over WiFi and executes responses locally. Built-in skills include LED control, buzzer tones, display rendering, joystick input, and HTTP requests. The project currently targets the RP2040-based Pico W and has not released firmware for the RP2350-based Pico 2 W, though the pin-compatible hardware should accept the same code with updated MicroPython firmware.

If you want to try this approach, pico-claw-micropython is the closest starting point. The project is small (three GitHub stars, no formal releases as of May 2026), but it demonstrates the core pattern: a microcontroller orchestrating multi-step AI workflows with zero local model inference.

Store Your Edge Agent Output in One Place

Fastio gives your Pico 2 agents 50GB of free cloud storage with auto-indexing for search and AI chat. No credit card required. Upload sensor data via HTTP and share results with your team.

Start 14-Day Trial

MicroPython support for the RP2350 is stable. Version 1.28.0, released April 6, 2026, provides dedicated firmware for both ARM and RISC-V modes on the Pico 2, along with a separate build for the Pico 2 W with WiFi support.

Setup takes a few minutes:

1. Download the Pico 2 W MicroPython firmware (.uf2 file) from micropython.org.
2. Hold the BOOTSEL button while connecting the Pico 2 W to your computer via USB.
3. The board appears as a mass storage device named "RP2350."
4. Drag the .uf2 file onto the drive.
5. The board reboots into MicroPython.

From there, the basic agent pattern is WiFi connection, LLM API call, and response execution. Here is a minimal MicroPython example that connects to WiFi and sends a sensor reading to Claude for classification:

import network
import urequests
import json
import gc

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("YOUR_SSID", "YOUR_PASSWORD")

while not wlan.isconnected():
    pass

payload = json.dumps({
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Classify: temp=23.5C humidity=67%"}]
})
headers = {
    "Content-Type": "application/json",
    "x-api-key": "YOUR_API_KEY",
    "anthropic-version": "2023-06-01"
}
response = urequests.post(
    "https://api.anthropic.com/v1/messages",
    data=payload,
    headers=headers
)
result = response.json()
print(result["content"][0]["text"])
response.close()
gc.collect()

This is standard MicroPython, not OpenClaw-specific code. The same pattern works with any LLM provider that offers an HTTP API.

Constraints to plan around on the RP2350:

• Allocate SRAM carefully. A 520KB budget fills quickly when buffering HTTP responses. Stream and parse incrementally when possible.
• Call gc.collect() between LLM requests. MicroPython's garbage collector needs manual hints on constrained hardware.
• Use watchdog timers. WiFi connections drop, API endpoints time out, and JSON parsing can fail. The RP2350's hardware watchdog prevents infinite hangs.
• Start with ARM firmware. The Cortex-M33 mode has broader MicroPython ecosystem support than the RISC-V mode.

If you are porting pico-claw-micropython code from the original Pico W, the main change is flashing the RP2350-specific MicroPython firmware. Pin assignments, WiFi APIs, and the HTTP client should work identically, though you should verify your application after porting since some edge cases in the RP2040 port behave slightly differently on RP2350.

A Pico 2 W agent generates data: sensor readings, classification results, logs, error reports. The board's 4MB of flash fills quickly, and local storage is not accessible to the rest of your team. You need somewhere to put this data where humans and other agents can find it.

Several options work, each with tradeoffs:

Local SD card adds cheap bulk storage through SPI, but the data stays physically on the board. Nobody can access it without plugging in.

S3 buckets provide reliable cloud storage, but the AWS SDK does not run on MicroPython. You would need to implement SigV4 request signing manually or route through a proxy.

Google Drive offers familiar file management, but its OAuth flow is complex to implement on a microcontroller with no browser.

Fastio provides a free workspace with 50GB of storage, an HTTP API that a MicroPython urequests call can hit directly, and built-in intelligence that auto-indexes uploaded files for search and AI chat. The Business Trial includes included credits, 5 workspaces, and no credit card requirement.

The practical pattern: your Pico 2 W agent collects data over a period (minutes or hours depending on the application), formats it as a JSON or CSV payload, and uploads it to a Fastio workspace via HTTP POST. On the Fastio side, Intelligence Mode indexes the uploaded files automatically. Team members can search across all agent output, ask questions about the data through Intelligence Mode, or download files through branded shares.

For teams deploying multiple Pico 2 agents, Fastio workspaces provide a coordination layer. Each agent writes to its own folder, audit trails track every upload, and workspace permissions control who sees what. The Fastio MCP server also means that other AI agents running on full computers can read and process the data your microcontroller agents upload, creating a bridge between edge collection and desktop analysis.

The current state of microcontroller agent orchestration is practical but narrow.

Working patterns today:

• Environmental monitoring agents that read temperature, humidity, or air quality sensors and call a cloud LLM to classify conditions or generate alerts
• Access control nodes that capture events (motion, RFID scans, door states) and ask an LLM to evaluate whether the pattern is normal
• Agricultural sensors that collect soil moisture and light data, then request crop-specific recommendations from a cloud model
• Industrial IoT nodes that stream vibration or current data and request predictive maintenance assessments

Current limitations:

• All reasoning requires WiFi. If the connection drops, the agent cannot think. Build local fallback logic for critical applications.
• No project has released RP2350-specific firmware for an OpenClaw-style agent framework. The pico-claw-micropython project targets RP2040, and PicoClaw requires Linux.
• The 520KB SRAM ceiling means complex multi-turn conversations with the LLM are not practical. Design agents for single-turn interactions: one prompt, one response, one action.
• Battery life with active WiFi is measured in hours, not days. Sleep modes help but interrupt the agent loop.

What is changing:

Texas Instruments announced microcontrollers with built-in NPU accelerators (TinyEngine) in March 2026, bringing dedicated ML inference hardware to sub-$1 chips. MicroPython's RP2350 support continues to mature, with v1.29.0 in preview as of May 2026. And the pico-claw-micropython project, while small, demonstrates that the agent orchestration pattern works on cheap hardware with minimal code.

The $7 Pico 2 W will not replace your laptop for running OpenClaw. But it fills a gap that laptops cannot: always-on, low-power, physically distributed agent nodes that feed data into shared workspaces where humans and full-powered agents can act on it.