How to Control LED Strips with Raspberry Pi and OpenClaw AI Agents

The global smart LED strip market reached $2.38 billion in 2026, with addressable strips growing at 15 to 20 percent annually and accounting for over 55 percent of dollar value in the segment. WS2812B strips, sold under the Adafruit NeoPixel brand and dozens of compatible labels, are the most popular addressable LED for hobbyist and home automation projects. Each LED in the chain has its own controller chip, so you can set every pixel to a different color and brightness from a single data line.

The Raspberry Pi is the default controller for these strips. The rpi_ws281x library uses the Pi's hardware PWM on GPIO 18 to drive hundreds of LEDs with microsecond timing, and the Adafruit CircuitPython NeoPixel library wraps it in a clean Python API. Getting a strip lit up takes about 20 minutes of wiring and a few lines of code.

The problem starts after the demo. Most tutorials walk you through a rainbow cycle, maybe a theater chase animation, and then stop. You end up with a script that runs one effect in a loop. If you want timed scenes (warm white at sunset, dim red at midnight, bright white when you walk in), reactive animations (flash on a webhook event, pulse when a sensor triggers), or preset management across multiple rooms, you need to build that orchestration yourself.

That is where an AI agent fits. OpenClaw, an open-source agent framework, runs on the same Raspberry Pi that controls your LED strip. It connects to cloud LLMs for reasoning and executes actions locally. Instead of writing cron jobs and conditional logic for every lighting scenario, you describe what you want and let the agent handle scheduling, sensor reactions, and preset switching. This guide covers the full path: wiring, Python control, scene management, and agent integration.

You need five components to get started.

Raspberry Pi 4 or 5 (2 GB+ RAM)

Either model works for LED control alone. If you plan to run OpenClaw on the same board, 4 GB RAM gives more headroom for the Node.js runtime alongside the Python LED controller. Use Raspberry Pi OS Lite (64-bit), which is required for OpenClaw and keeps resource usage low.

WS2812B LED strip

Available in densities from 30 to 144 LEDs per meter, with 60 LEDs/m being the most common for general lighting. Buy IP30 (no waterproofing) for indoor use or IP65/IP67 for outdoor installations. Strips come in 1-meter and 5-meter rolls. A 1-meter strip with 60 LEDs is enough to test everything in this guide.

5V power supply

Each WS2812B LED draws up to 60 mA at full white brightness. A 60-LED strip can pull 3.6 A at peak, so a 5V 4A supply provides enough headroom. For longer strips, size accordingly: 300 LEDs need a 5V 18A supply, and you should inject power at both ends of the strip to prevent voltage drop and color shift at the far end. Do not power more than a handful of LEDs from the Pi's 5V pin. The Pi cannot source enough current and may damage the board.

Level shifter (optional but recommended)

The Pi's GPIO outputs 3.3V logic, but WS2812B LEDs expect 5V data signals. Many strips work fine with 3.3V input for short runs under 1 meter. For reliable operation at longer distances, use a 74AHCT125 level-shifter chip (connect Pi GPIO 18 to pin 1A, take the output from pin 1Y to the strip's data-in) or a 1N4001 diode on the power line (cathode to strip 5V, anode to power supply 5V), which drops the supply voltage just enough to bring 3.3V into the valid input range. The 74AHCT125 chip costs under $2 and eliminates signal integrity issues entirely.

Jumper wires

Three connections: Pi GPIO 18 to strip data-in, power supply positive to strip 5V, and a shared ground connecting the Pi, power supply, and strip. The shared ground is critical. Without it, the data signal has no reference voltage and the strip will flicker or show random colors.

Wiring Steps

1. Connect the power supply's 5V output to the strip's 5V pad (red wire) and the power supply ground to the strip's GND pad (white or black wire).

2. Connect a jumper from the Pi's GPIO 18 (physical pin 12) to the strip's data-in pad (green wire). If using a 74AHCT125, route GPIO 18 through the chip first.

3. Connect the Pi's GND (physical pin 6 or any ground pin) to the power supply's ground. This shared ground ensures clean data transmission.

4. Check the strip's directional arrow or marking. WS2812B strips are unidirectional: data flows from input to output along the chain.

The rpi_ws281x library provides hardware PWM control for WS2812B strips on Raspberry Pi. Adafruit's CircuitPython NeoPixel library builds on top of it with a friendlier API. Install both.

Disable Onboard Audio

GPIO 18 uses the PWM0 channel, which conflicts with the Pi's audio output. If you skip this step, the library will crash with a segmentation fault. Edit /boot/config.txt (or /boot/firmware/config.txt on newer OS versions), change dtparam=audio=on to dtparam=audio=off, and reboot.

Install the Libraries

sudo pip3 install rpi_ws281x adafruit-circuitpython-neopixel

If you use a Python virtual environment, run scripts with sudo -E env PATH=$PATH python3 to maintain root access (required for hardware PWM) while keeping your virtualenv packages available.

Test the Strip

Create a file called test_strip.py:

import board
import neopixel

LED_COUNT = 60
pixels = neopixel.NeoPixel(board.D18, LED_COUNT, brightness=0.3, auto_write=False)

pixels.fill((255, 0, 0))
pixels.show()

Run it with sudo python3 test_strip.py. Every LED should turn red at 30 percent brightness. The auto_write=False setting prevents the library from pushing data to the strip on every pixel change. Instead, you build the full frame in memory and call pixels.show() once, which avoids visible flickering during complex animations.

Key Parameters

• board.D18 maps to GPIO 18. You can also use board.D12, board.D21, or board.D10, but GPIO 18 is the standard choice because it uses hardware PWM by default.

• brightness accepts a float from 0.0 to 1.0. Setting this to 0.3 during development saves power and is easier on the eyes.

• pixel_order defaults to GRB, which is correct for WS2812B. If your colors appear wrong (red and green swapped), try neopixel.RGB or neopixel.RGBW for four-channel strips.

Once the test works, you have confirmed that wiring, power, and software are all correct.

Store and sync your lighting presets across every Pi

Free 50 GB workspace, no credit card, MCP endpoint for your OpenClaw agent's reads and writes. Upload scene configs once, pull them from any Raspberry Pi.

Sign Up Free

A "scene" is a named lighting state: a set of colors, brightness levels, and optional animation parameters that you can apply as a unit. Defining scenes as Python functions or dictionaries loaded from a config file makes them composable and easy to trigger from any control layer, whether that is a cron job, a REST endpoint, or an AI agent.

Static Scenes

Static scenes set every pixel to a fixed color and brightness:

def warm_evening(pixels):
    pixels.fill((255, 147, 41))
    pixels.brightness = 0.4
    pixels.show()

def bright_work(pixels):
    pixels.fill((255, 255, 200))
    pixels.brightness = 1.0
    pixels.show()

def night_dim(pixels):
    pixels.fill((30, 0, 0))
    pixels.brightness = 0.1
    pixels.show()

These three functions cover the most common use case: ambient lighting that changes with time of day. The color values are RGB tuples from 0 to 255.

Animated Scenes

Animations loop through color or position changes at a set interval. A breathing effect fades brightness up and down:

import time
import math

def breathe(pixels, color=(0, 100, 255), speed=0.02):
    step = 0
    while True:
        brightness = (math.sin(step) + 1) / 2
        pixels.fill(color)
        pixels.brightness = brightness * 0.5
        pixels.show()
        step += speed
        time.sleep(0.02)

A color wipe rolls a new color across the strip one pixel at a time:

def color_wipe(pixels, color, wait=0.02):
    for i in range(len(pixels)):
        pixels[i] = color
        pixels.show()
        time.sleep(wait)

Scene Configuration with JSON Store scene definitions in a JSON file so you can edit presets without changing Python code:

{
  "scenes": {
    "morning": {"color": [255, 200, 150], "brightness": 0.6},
    "focus": {"color": [255, 255, 255], "brightness": 1.0},
    "movie": {"color": [10, 5, 30], "brightness": 0.15},
    "off": {"color": [0, 0, 0], "brightness": 0}
  }
}

A small Flask or FastAPI server that loads this config and exposes a /scene/<name> endpoint turns the Pi into a networked lighting controller. Any HTTP client can switch scenes with a single request, including scripts, phone apps, and AI agents.

OpenClaw runs on a Raspberry Pi alongside the LED control software. The official Raspberry Pi installation takes about 30 minutes: update the OS, install Node.js, run the install script, and complete the onboarding wizard that configures your LLM provider and messaging channel. OpenClaw's documentation covers the full process at docs.openclaw.ai/install/raspberry-pi.

The Pi does not run LLMs locally. OpenClaw sends reasoning requests to cloud APIs (Anthropic, OpenAI, or Google) and executes actions on-device. This keeps CPU and memory usage low enough that the LED controller and OpenClaw share the same Pi without competing for resources.

Architecture

The recommended integration pattern puts an HTTP bridge between OpenClaw and the LED controller:

1. A Python process owns the LED strip hardware and runs a lightweight HTTP server (Flask or FastAPI) with endpoints for scene control: /scene/morning, /scene/off, /status, and similar routes.

2. OpenClaw interacts with these endpoints as part of its task execution. When you message the agent "switch to movie mode," it resolves the request to an HTTP call against the local server.

3. The two processes stay decoupled. You can test the LED controller independently, and OpenClaw does not need to know about GPIO pins, pixel buffers, or timing constraints.

This is the same decoupled pattern used for other Raspberry Pi hardware projects with OpenClaw. The agent handles reasoning (when to change scenes, how to respond to events, what schedule to follow) and the Python process handles hardware (pixel data, PWM timing, power management).

What the Agent Adds

Without an agent, you write explicit rules: at 7 PM run the evening scene, at 11 PM run the night scene, when motion is detected run the bright scene for 5 minutes. Every new behavior requires a new rule and a code change.

With an agent, you describe intent. "Keep the lights warm in the evening, dim them when I go to bed, and flash green when my deploy pipeline succeeds." The agent interprets the intent, maps it to available scenes, and handles timing and event logic. If you add a new scene to the config file, the agent can discover and use it without additional code.

For event-driven lighting, the Pi can receive incoming webhooks from CI/CD pipelines, smart home platforms, or calendar APIs. A failed build could trigger a red pulse, while a completed deployment could trigger a brief green color wipe across the strip.

Scene configuration files, animation scripts, and wiring documentation accumulate quickly once you move past a single strip in one room. If you run multiple Pi-controlled LED installations or collaborate with others on lighting setups, you need a central place to store and version these files.

Local storage on the Pi's SD card works for a single device but breaks down when you want to sync configurations across multiple Pis, share presets with a collaborator, or recover after an SD card failure. A Git repository handles versioning but requires setup and does not provide a browsable interface for non-developers. S3 buckets store files cheaply but have no built-in versioning UI or semantic search.

Fast.io workspaces fill that gap. Upload your scene JSON files, animation scripts, and wiring notes to a workspace. Each file gets automatic versioning, so you can roll back a broken config without digging through commit history. Share the workspace with collaborators through a branded link, and they can download or update presets without needing SSH access to your Pi.

For agent-driven workflows, Fast.io's MCP server gives OpenClaw a way to read and write workspace files directly. The agent can pull the latest scene config from Fast.io on startup, push updated presets after you modify them through a chat message, and maintain an audit trail of every configuration change. Intelligence Mode indexes uploaded files for semantic search, so you can ask the agent "which preset uses the warmest color temperature?" and get an answer grounded in your actual config files rather than a guess.

The free tier includes 50 GB of storage, 5,000 AI credits per month, and 5 workspaces with no credit card required. That covers lighting configuration management across dozens of installations with room to spare.