Here's a Wi-Fi chip the size of a fingernail — one sentence, and it writes its own program and runs it. It understands what the camera sees and decides how to respond. It switches on the lights, spins the motor. It remembers your habits and gets smarter the more you use it.

A complete AI Agent that codes and acts for itself — Ameba-Claw.

What Is Ameba-Claw?

Open-source projects like OpenClaw have shown the world how AI can orchestrate tools and handle complex tasks through conversation on PCs and servers. Ameba-Claw takes that same "natural language as programming" philosophy out of the digital world and into the real, physical world of IoT.

Ameba-Claw is an on-device agent framework built for microchips. The full Agent loop — perception, decision, execution, and memory — runs entirely on the chip itself. It can generate new capabilities at runtime and continuously expand what it can do, instead of being locked to pre-flashed firmware.

So what happens when this capability enters an IoT scenario?

You tell a device running Ameba-Claw: "Get ready for a movie."

The Agent instantly understands this casual phrase. It reasons autonomously on-device, coordinates with multiple devices via MCP: dims the ambient lights, lowers the projector screen, and sets the air conditioner to a comfortable 24°C.

That's just one scenario. How does it handle vision processing, network communication, and UI rendering?

In Practice

The four demos below were all generated and run live — no business logic was pre-loaded. The same hardware can take on a completely different role depending on the scenario: surveillance terminal, automation controller, interactive information display — all redefinable.

Demo 1 · Vision: USB Camera + LCD Dynamic Monitoring

Realtek's powerful USB Host capability drives a standard USB UVC camera directly — no dedicated vision processing unit required. It can capture photos, store them locally, and call a multimodal model to understand the image, answering questions like "What's happening in this picture?"

For example: a monitoring terminal that automatically detects scene changes. The device captures a frame every 5 seconds, compares it to the previous frame, highlights new, moved, and unchanged objects on screen, and provides a change summary.

This demo chains together the complete end-to-end pipeline: USB Host → UVC camera → on-demand multimodal model → LCDC real-time rendering. Tasks that once required a dedicated vision module now work with just a Wi-Fi chip and a standard camera.

In other scenarios, you can ask it directly:

- Is that a person or an animal at the door?

- Which indicator light on the device panel is on?

- Is the cabinet door fully closed?

Demo 2 · Zero-Flash Self-Organizing Network: LAN Walkie-Talkie

Ameba-Claw natively integrates WeChat, QQ, Telegram, and WebIM — messages from all platforms feed into the Agent loop.

You send a message via WeChat:

"Make a walkie-talkie, start receiving..."

Two dev boards with absolutely no pre-written business code generate their code at runtime, automatically form a LAN via UDP broadcast, drive the DMIC to capture microphone audio, and drive I2S to output audio through a speaker. Seconds later, the walkie-talkie is live. Whether it's video surveillance or a LAN walkie-talkie, the core capability is the same: Ameba-Claw translates naturallanguage into Lua scripts and runs them.

Demo 3 · Zero-Code Hardware Interaction: LVGL HMI Graphic Control Panel

When you say you need a hardware control panel with a UI, Ameba-Claw automatically invokes the chip's LCDC and LVGL graphics library. It renders an "LED Studio" control panel on screen, and you can control the underlying hardware directly through UI widgets — drag a slider on screen and the light changes color in real time.

From UI rendering to SPI hardware control, the entire flow is completed by the Agent at runtime. Zero code, full software-hardware interaction.

Demo 4 · Adaptive Full-UI App Rendering: 2048 Game

Beyond control applications, Ameba-Claw can also host complete graphical application logic. It reads the screen resolution autonomously and calculates precise padding and board margins on-device, ensuring the UI renders correctly on screens of any resolution — including tile sliding, number merging, transition animations, and full game logic.

Hardware Foundation: RTL8721F

The advantages of Ameba-Claw are built on the hardware capabilities of the RTL8721F.

What does an on-device Agent need? Enough memory to hold context, enough storage to record long-term memory, rich peripherals to connect sensors and actuators, and stable wireless connectivity.

Full-scenario networking: Dual-band Wi-Fi 6 (2.4G/5G) as standard. The 5GHz band ensures real-time response in demanding environments. Ethernet and BLE 5.0 also supported — three network paths available in parallel for improved connection reliability.
Runtime memory: High-speed DQ16 PSRAM for larger system prompts, memory summaries, and multi-turn conversation history. Accelerates complex GUI rendering.
Storage expansion: Supports NOR or NAND Flash and SD cards, providing ample space for long-term memory, images, and logs.
Display output: Built-in LCDC hardware controller + MJPEG decode + PPE graphics engine. UI and surveillance video display directly, consuming no additional compute.
External expansion: USB 2.0 HS host/device dual mode. Plug-and-play with UVC cameras, USB drives, and other standard peripherals.

These aren't luxury features — they are the prerequisites for an Agent to function on-device.

Local Memory: Editable and Persistent

To enable continuously evolving behavior, Ameba-Claw stores long-term configuration and key information in local Flash:

SOUL.md — Defines the device's personality and behavioral boundaries (e.g., "You are a cold-storage maintenance expert")
USER.md — Records preferences and special permissions
MEMORY.md — Automatically accumulates device-specific, structured long-term memory summaries
SKILL.md — Supports the standard Skill format spec; loads different Skills on demand via YAML headers

Developers can edit these files directly. They participate in inference as the Agent's long-term context and provide persistent configuration and constraints for Skills. Data stays on-device, with hardware encryption and a secure execution environment — privacy is fully in your hands.

Up and Running in Three Minutes

Ameba-Claw is fully open source. Code, documentation, and an online flashing tool are all ready to go:

1. Get the hardware: Grab an RTL8721F development board.

2. Quick setup: Flash firmware via the web tool, connect to Wi-Fi, configure your LLM API Key and IM platform token.

3. Start talking: Open your chat app, ask "What's the temperature right now?" or say "Take a photo for me" — the device responds instantly.

Developer-friendly: no Linux build environment, no Python dependencies, no container networking to configure. Just the Ameba-RTOS development environment (or use the pre-compiled firmware), and your device has Agent capability.

Pick up the dev board beside you. In three minutes, your device will understand its first sentence.

Try it now.

Related Resources

📦 Get the Open Source Code: https://github.com/Ameba-AIoT/ameba-claw

📖 Developer Guide & Online Flashing Tool

- Usage Guide:aiot.realmcu.com/zh/latest/ameba_claw/index.html

- Online Flash Tool: aiot.realmcu.com/zh/resource/web_flash_tool.html