How to Build a Smart Irrigation Controller with OpenClaw on Raspberry Pi

A basic Raspberry Pi irrigation controller reads a soil moisture sensor and opens a valve when the reading drops below a threshold. It works. But it also waters the garden at 6 PM when rain is forecast for 9 PM, runs the same duration whether the soil is sandy loam or heavy clay, and has no concept of seasonal adjustment.

Smart irrigation controllers that account for weather data and soil conditions reduce water usage by 20-50% compared to fixed timers, according to the U.S. Department of Energy. The EPA's WaterSense program found that controlled research studies averaged 50% savings, while real-world case studies on home landscapes averaged around 30%.

The gap in most DIY Pi irrigation guides is the decision layer. The hardware tutorials are solid: wire a capacitive sensor to an ADC, connect a relay to a solenoid valve, write a Python script with a moisture threshold. But the watering logic is a simple if/else. There is no consideration of tomorrow's weather, no memory of how long last week's watering lasted, and no adjustment for plant growth stages.

OpenClaw fills that gap. Running on the same Raspberry Pi that controls your valves, it connects sensor readings and weather API data to an LLM that reasons about whether watering is actually needed right now. The agent can skip a cycle because rain is coming, extend duration because last week was unusually hot, or reduce output because fall is approaching and your tomatoes need less water.

This is not about replacing a simple Python script with an over-engineered AI system. It is about adding a reasoning layer that makes the same hardware more water-efficient.

The hardware bill for this project stays under $50 beyond the Pi itself. You need four main components: a Raspberry Pi (model 4 or 5 with at least 4GB RAM), a capacitive soil moisture sensor with an analog-to-digital converter, a relay module, and a solenoid valve.

Capacitive soil moisture sensor ($3-8): Choose capacitive over resistive. Resistive sensors corrode within weeks because they pass current directly through the soil. Capacitive sensors measure the dielectric permittivity of surrounding soil without exposed metal contacts. They last for seasons instead of weeks. Most Pi-compatible modules ship with an analog output, so you will need an ADC (analog-to-digital converter) like the ADS1115 to read them, since the Pi's GPIO pins only handle digital signals.

ADS1115 ADC module ($3-5): This converts the sensor's analog voltage to a digital reading over I2C. Connect SDA to GPIO 2 (pin 3), SCL to GPIO 3 (pin 5), VDD to 3.3V, and GND to ground. The sensor's analog output connects to one of the ADC's four input channels.

Relay module ($3-5): A single-channel 5V relay module works for one zone. The signal pin connects to any available GPIO pin (GPIO 17 is a common choice). The relay switches the solenoid valve's power circuit. Use an optically isolated relay to protect the Pi's GPIO from voltage spikes when the solenoid's coil de-energizes.

Solenoid valve ($10-20): A 12V normally-closed solenoid valve connects to your water supply via garden hose fittings. "Normally closed" means water only flows when the relay energizes the valve, so a power failure or crash keeps the water off rather than flooding your garden.

Power supply: The Pi runs on USB-C (5V/3A for Pi 5), but the solenoid needs 12V. A 12V/2A DC adapter powers the valve through the relay. Do not try to power the solenoid from the Pi's GPIO pins. They supply 3.3V at a few milliamps, which is not close to what a solenoid coil requires.

For multi-zone setups, use a 4-channel or 8-channel relay board and add solenoid valves for each zone. Each zone gets its own GPIO pin assignment.

OpenClaw installs on Raspberry Pi OS with a single command. The official installer handles dependencies, configuration, and service setup.

Pi requirements: A Raspberry Pi 5 with 8GB RAM is the recommended platform. The Pi 4 with 8GB also works. OpenClaw's agent runtime plus the sensor polling and relay control scripts run comfortably within 4GB, but 8GB gives headroom for concurrent tasks. Use a high-quality SD card or, better, an M.2 SSD via the Pi 5's HAT+ for reliability. SD cards in always-on applications can fail after months of continuous writes.

Network: The Pi needs internet access for LLM API calls and weather data. A wired ethernet connection is more reliable than Wi-Fi for an always-on outdoor controller, especially if the Pi sits in a shed or garage with weak signal. OpenClaw supports multiple LLM providers (Claude, GPT-4, Gemini, local models via Ollama), so choose based on your preference and budget. Local models eliminate API costs and latency but require more RAM.

Sensor access from the agent: OpenClaw agents interact with the system through tools and commands. For irrigation, the agent needs two capabilities: reading the soil moisture sensor and controlling the relay GPIO pin. Python scripts handle the low-level hardware interaction. A read_moisture.py script queries the ADS1115 over I2C and returns a normalized moisture percentage. A set_valve.py script takes "on" or "off" as an argument and toggles the GPIO pin connected to the relay.

The OpenClaw agent calls these scripts as system commands. When it needs a moisture reading, it runs the sensor script and gets back a number. When it decides to water, it runs the valve script. The agent never touches GPIO registers directly. It delegates hardware control to purpose-built scripts and focuses on the decision logic: should we water, for how long, and why.

Weather API integration: Register for a free API key from a weather service like OpenWeatherMap or Open-Meteo. The agent can fetch forecast data by calling a weather script that returns precipitation probability, temperature, and humidity for the next 24-48 hours. Open-Meteo is particularly convenient because it requires no API key for basic forecast data and returns JSON that is easy to parse.

Store Your Irrigation Logs Where Any Agent Can Query Them

Upload sensor data, watering decisions, and historical patterns to a Fast.io workspace. Intelligence Mode indexes everything for semantic search, so you can ask questions about your garden's water usage without parsing raw logs. 50GB free, no credit card. Built for openclaw raspberry smart irrigation controller agent workflows.

Sign Up Free

This is where OpenClaw's reasoning separates a smart irrigation controller from a threshold-based timer. Instead of "moisture below 40%, turn on water," the agent evaluates multiple inputs before making a decision.

Inputs the agent considers:

• Current soil moisture reading (from the capacitive sensor)
• Weather forecast for the next 24 hours (precipitation probability, temperature, wind)
• Time of day (watering at midday loses more to evaporation than early morning)
• Historical watering data (when did we last water, how much, what was the result)
• Plant-specific thresholds (tomatoes need more water than lavender)
• Soil type characteristics (sandy soil drains fast, clay retains moisture longer)

Decision examples the agent can reason through:

The sensor reads 35% moisture, which is below the 40% threshold for tomatoes. A simple controller would start watering immediately. But the agent checks the forecast and sees an 80% chance of rain in 6 hours. It decides to wait. If the rain arrives, it saved water. If the rain does not arrive by tomorrow morning, it waters then.

The sensor reads 42% moisture, technically above threshold. But temperatures hit 38°C today and the forecast shows no rain for 5 days. The agent recognizes that moisture will drop quickly in this heat and waters proactively in the early morning when evaporation losses are lowest.

Saturday's watering ran for 15 minutes but the moisture reading only climbed to 45% instead of the expected 60%. The agent notes this and extends the next watering cycle to 20 minutes, compensating for drier soil conditions or increased plant uptake.

Logging decisions: Every watering decision, whether the agent waters or skips, should be logged with the reasoning. This creates a record you can review: "Skipped watering at 18:00, moisture 37%, rain forecast 82% probability at 22:00" or "Watered zone 2 for 12 minutes, moisture was 28%, no rain expected for 72 hours, adjusted duration up from 10 minutes based on last cycle's below-target result."

This log becomes valuable over weeks. You can see patterns in water usage, catch sensor drift (readings that no longer correlate with actual soil conditions), and fine-tune the agent's thresholds for your specific garden.

An irrigation controller needs to run reliably without daily attention. The OpenClaw agent handles scheduling through its built-in task management, but you should also build in safeguards.

Polling schedule: Configure the agent to read sensors at regular intervals. Every 15-30 minutes is sufficient for most gardens. More frequent polling wastes cycles without adding useful data, since soil moisture changes gradually. During heat waves or immediately after watering, you might temporarily increase the frequency to every 5 minutes to track moisture recovery curves.

Safety limits: Hard-code maximum watering durations in the valve control script, not just in the agent's reasoning. If a bug or hallucination tells the agent to water for 3 hours, the script should cap execution at 30 minutes regardless. This is a defense-in-depth principle: the agent makes smart decisions 99% of the time, but the hardware script enforces physical safety 100% of the time.

Watchdog timer: Set up a system-level watchdog that closes all valves if the agent process crashes or hangs. A cron job that checks whether the valve has been open for more than the maximum duration and forces it closed is a simple but effective safeguard. Water damage from a stuck-open valve is the worst failure mode for any irrigation system.

Multi-zone management: For gardens with different plant types or sun exposure, run separate sensor-valve pairs for each zone. The agent manages all zones as independent channels, each with its own moisture thresholds, watering schedules, and plant profiles. Zone 1 (shade garden with ferns) might need watering every three days, while Zone 3 (south-facing raised bed with peppers) might need daily attention in summer.

Remote monitoring: Once the system is running, you want visibility without physically checking the Pi. The agent's decision logs and sensor readings are valuable data. This is where persistent storage becomes important.

Fast.io workspaces give you a practical option for remote access to your irrigation data. The agent can upload daily log files, sensor readings, and watering summaries to a shared workspace using the Fast.io MCP server. With Intelligence Mode enabled, those uploaded logs become searchable and queryable. You can ask questions like "how much water did zone 2 use last week" or "show me days where the agent skipped watering" without digging through raw log files.

The free agent plan includes 50GB of storage and 5,000 monthly credits with no credit card required, which is more than enough for years of irrigation logs. If you run multiple Pi-based controllers (greenhouse, front yard, vegetable garden), each can upload to the same workspace, giving you a unified view of water usage across all sites.

Alternative approaches include pushing data to a local Home Assistant instance, an MQTT broker, or a cloud dashboard like Grafana with InfluxDB. Fast.io is simpler to set up since there is no server to maintain, but any of these options work.

Real gardens are messy. Sensors get buried under mulch, solenoids stick, and watering needs change dramatically between April and August. Here is what to watch for after deployment.

Sensor calibration drift: Capacitive sensors can drift over months as the soil around them compacts or as mineral deposits build up on the sensor surface. Recalibrate quarterly by taking a moisture reading, then manually checking the soil with a finger test or a reference meter. If the sensor reads 50% but the soil is dry, clean the sensor and update the calibration offset in your reading script.

Stuck solenoid valves: Solenoid valves can stick open or closed if debris gets into the mechanism or if the coil weakens. Add a flow sensor ($5-10) downstream of the valve to verify that water is actually flowing when the valve is commanded open. If the agent opens the valve but the flow sensor reads zero, flag an alert. Similarly, if the flow sensor reads non-zero when the valve should be closed, something is wrong.

Seasonal threshold adjustment: Static moisture thresholds work poorly across seasons. Summer tomatoes in full fruit need soil moisture around 60-70%, while the same plants in early spring establishment might be fine at 45-50%. Configure your agent with seasonal profiles or, better, let it learn from historical data. If the agent sees that moisture drops from 60% to 30% in 8 hours during July heat, it should adjust its watering strategy accordingly rather than following the same rules it used in mild April weather.

Power and connectivity failures: SD card corruption is the most common failure mode for always-on Pi deployments. Use an SSD if possible. For power outages, the normally-closed solenoid valve defaults to off, which is the correct safe state. When power returns, the agent should read the sensor before doing anything rather than assuming it needs to water. If the Pi loses internet, the agent cannot fetch weather forecasts. Configure a fallback mode that uses sensor data alone, essentially reverting to threshold-based watering until connectivity returns.

Water pressure issues: If your system shares a water line with household plumbing, pressure drops when someone runs a shower or dishwasher can reduce flow through the irrigation valve. The agent cannot easily detect this, but a flow sensor helps. Log flow rates alongside watering duration so you can spot patterns where watering ran for the expected time but delivered less water than usual.

Winter shutdown: In cold climates, drain the system before the first frost. Solenoid valves and supply lines will crack if water freezes inside them. The agent should have a seasonal shutdown mode that disables watering entirely and reminds you (via a log entry or notification) to drain the physical plumbing.