Smart home gear has been around for years now. We’ve got the bulbs,
the sensors, the thermostats, the cameras — the whole lot. And yet, most
“smart” homes are really just programmable homes. Your lights
turn on at sunset because you told them to. Your thermostat follows a
schedule because you set one. Nothing about that is intelligent. It’s
just a bunch of if-then rules pretending to be smart.
That changes when you bring OpenClaw into the mix.
Connecting OpenClaw to Home Assistant creates
something genuinely different: a home that doesn’t just follow rules but
actually reasons about what’s happening and responds
accordingly. An AI agent that can see your sensor data, understand
context, and take action — not because you wrote an automation for every
possible scenario, but because it can figure out the right thing to do
on its own.
If you’re new to the platform, our WTF is OpenClaw guide covers the
basics. But if you already know the vibe and want to make your smart
home actually smart, you’re in the right place.
What an
AI-Powered Smart Home Actually Looks Like
Let’s skip the marketing fluff and talk about what day-to-day life
looks like when your ai smart home setup is running
properly.
It’s a Tuesday morning. Your phone alarm goes off at 6:45. Your
OpenClaw agent — let’s say you’re running clawdbot — notices the alarm
event and kicks off a morning sequence. But here’s the thing: it doesn’t
run the same routine every day. It checks the weather forecast first.
It’s grey and cold, so the heating bumps up ten minutes earlier than
usual. The kitchen lights come on at a warmer colour temperature because
sunrise is still an hour away. Your espresso machine fires up. The
bathroom extractor fan pre-runs because humidity from last night’s
shower is still lingering — the sensor says 68%.
None of that required a mega-automation with dozens of conditions.
Clawdbot looked at the sensor data, checked external context, and made
reasonable decisions. That’s the difference between a programmable home
and an AI-powered one.
Later that day, you’re at work. A motion sensor in the hallway
triggers, but your phone’s GPS shows you’re fifteen miles away. A
traditional automation might blast a notification or trigger an alarm.
Your OpenClaw agent checks the calendar first — oh, the cleaner is
scheduled for 2pm. It cross-references the time, confirms it’s
plausible, and does nothing. No false alarm. No panicked phone check in
a meeting.
In the evening, you tell moltbot (maybe you prefer running that agent
for home stuff) via Telegram: “Movie night.” It dims the living room
lights, sets the TV input, adjusts the thermostat slightly warmer since
you’ll be sitting still for two hours, and mutes notifications on
non-critical sensors. You didn’t build a “movie night” scene. The agent
inferred what movie night means and acted on it.
That’s the vision. Now let’s build it.
How OpenClaw Talks to Home
Assistant
There are three solid methods to connect openclaw home
assistant setups, and which one you choose depends on your
comfort level and what you want to achieve.
Home Assistant REST API
This is the most straightforward approach. Home Assistant exposes a
powerful REST API that lets you query states, trigger services, and fire
events over HTTP. OpenClaw agents can call these endpoints directly
using webhook skills or custom scripts.
The API gives you access to everything: entity states, service calls,
template rendering, event firing, and history. For most people, this is
the method to start with. It’s well-documented, works over your local
network or via Nabu Casa’s cloud, and doesn’t require any additional
infrastructure.
You’ll need a long-lived access token from Home Assistant (Settings →
Users → your profile → Long-Lived Access Tokens). Keep that token secure
— treat it like a password.
MQTT Integration
If you’re already running an MQTT broker (Mosquitto is the popular
choice), this opens up a real-time, event-driven connection between
OpenClaw and Home Assistant. Instead of polling the API for state
changes, your agent subscribes to MQTT topics and reacts instantly when
something changes.
This is the method you want for anything latency-sensitive: security
automations, presence detection responses, or anything where a
two-second delay matters. MQTT is lightweight, fast, and battle-tested
in the IoT world.
The setup involves pointing both Home Assistant’s MQTT integration
and your OpenClaw agent at the same broker. Your agent subscribes to
homeassistant/# topics and publishes commands back.
Webhooks (Bidirectional)
Webhooks work in both directions. Home Assistant can fire webhook
automations that hit an OpenClaw endpoint when something happens, and
OpenClaw can call Home Assistant’s webhook triggers to kick off
automations on that side.
This is particularly useful for openclaw automation
scenarios where you want Home Assistant to handle the low-level device
control (it’s great at that) while OpenClaw handles the high-level
reasoning. A sensor change fires a webhook to OpenClaw, the agent
decides what to do, and sends commands back. Best of both worlds.
Connecting
OpenClaw to Home Assistant: The Setup
Let’s walk through getting the REST API method running, since it’s
the foundation everything else builds on.
Get Your Home Assistant Details Sorted
You need two things from Home Assistant: your instance URL and an
access token. If you’re running Home Assistant OS, the URL is typically
http://homeassistant.local:8123. If you’re using Nabu Casa,
you’ll have a https://xxxxx.ui.nabu.casa URL instead.
For the token, open Home Assistant, click your profile in the
bottom-left, scroll to the bottom, and create a Long-Lived Access Token.
Copy it immediately — you won’t see it again.
Store Credentials in OpenClaw
Drop your credentials into your OpenClaw environment. The cleanest
approach is adding them to your .env file:
HA_URL=http://homeassistant.local:8123
HA_TOKEN=your_long_lived_access_token_hereTest the Connection
A quick curl command confirms everything works:
curl -s -H "Authorization: Bearer $HA_TOKEN" \
-H "Content-Type: application/json" \
"$HA_URL/api/" | jqYou should get back a JSON response with
{"message": "API running."}. If you get a 401, your token
is wrong. If you get a connection refused, check your URL and make sure
Home Assistant is accessible from wherever OpenClaw is running.
Create a Helper Script
Build a lightweight wrapper that your OpenClaw agent can call.
Something like this:
import os
import requests
HA_URL = os.environ["HA_URL"]
HA_TOKEN = os.environ["HA_TOKEN"]
HEADERS = {
"Authorization": f"Bearer {HA_TOKEN}",
"Content-Type": "application/json",
}
def get_state(entity_id):
r = requests.get(f"{HA_URL}/api/states/{entity_id}", headers=HEADERS)
return r.json()
def call_service(domain, service, data=None):
r = requests.post(
f"{HA_URL}/api/services/{domain}/{service}",
headers=HEADERS,
json=data or {},
)
return r.json()
def get_all_states():
r = requests.get(f"{HA_URL}/api/states", headers=HEADERS)
return r.json()Wire It Into Your Agent
Now your OpenClaw agent can use these functions to query and control
Home Assistant. You can expose them as tools the agent can call, or
build higher-level skills that combine multiple API calls into coherent
actions.
The real magic happens when you give your agent a description of your
home — what rooms exist, what devices are in each room, and what the
entity IDs are. Drop that into a context file and your agent can reason
about your home intelligently.
Set Up Scheduled Checks
Use OpenClaw’s cron functionality to have your agent periodically
check on things. Our cron jobs and automations
guide covers the scheduling side in detail, but the basics are
simple: set up a recurring task that pulls sensor states and lets the
agent decide if anything needs attention.
Real
Automation Examples That Actually Make Sense
Here are concrete openclaw automation examples that
go beyond the usual “turn lights on at sunset” fare.
The Context-Aware Morning Routine
Your agent checks: alarm time (from your phone), weather forecast,
calendar (any early meetings?), indoor temperature, humidity levels, and
whether it’s a workday or weekend. It then orchestrates: heating
adjustments, light scenes appropriate for the time and weather, kitchen
appliance triggers, and even a spoken briefing through a smart speaker —
today’s weather, commute conditions, first meeting time. Different every
day because the context is different every day.
Intelligent Security Response
Motion detected while you’re away doesn’t automatically mean panic
mode. Your agent cross-references: who’s expected (calendar, shared
family calendars), time of day plausibility, which specific sensor
triggered (front door vs random hallway), whether a known phone is on
the WiFi, and recent delivery notifications in your email. The response
scales: everything checks out means silent log entry. Something’s off
means camera snapshot sent to your phone with context. Nothing adds up
means full alert. No more crying wolf.
Energy Optimisation That Learns
Your agent tracks energy usage patterns over time. It notices the
tumble dryer runs during peak tariff hours and suggests shifting it. It
spots that the upstairs heating runs all day despite nobody being up
there until evening. It notices the hot water schedule heats a full tank
even on days you shower at the gym. Over weeks, it builds a picture and
makes recommendations — or just quietly optimises if you give it
permission.
Presence-Based Comfort
Beyond simple “is someone home” binary logic, your agent reasons
about where in the house people are and what they’re
likely doing. Motion in the kitchen at 18:30 probably means cooking —
extraction fan on, under-cabinet lights up, maybe suggest a recipe based
on what’s in the fridge (if you’re really committed to the
integration). Everyone clustered in the living room on a Friday evening
— adjust lighting and temperature for that zone, scale back everywhere
else. The house breathes with you rather than following rigid
schedules.
The Gotchas: What You Need to
Know
Let’s be honest about the rough edges, because there are some.
Latency matters more than you think. If your
OpenClaw agent runs in the cloud and your Home Assistant is local, every
API call has a round trip. For lights responding to motion, that delay
is noticeable and annoying. Keep latency-sensitive automations in Home
Assistant’s native automation engine and use OpenClaw for the
higher-level reasoning layer. Don’t try to replace Home Assistant’s
automations entirely — complement them.
Token security is on you. That long-lived access
token has full access to your Home Assistant instance. Anyone with it
can unlock your doors, disable your alarm, and control every device.
Store it properly, don’t commit it to repos, and rotate it
periodically.
AI reasoning isn’t deterministic. The same situation
might get slightly different responses on different days. For most
things — lighting, temperature, convenience stuff — that’s fine and even
desirable. For security-critical automations, keep those deterministic
in Home Assistant and let OpenClaw layer intelligence on top rather than
being the sole decision-maker.
Rate limits and API load. If your agent polls every
entity every thirty seconds, you’re going to hammer your Home Assistant
instance unnecessarily. Be strategic: poll infrequently for non-urgent
data, use webhooks or MQTT for real-time needs, and cache states locally
where possible.
The entity ID problem. Home Assistant entity IDs can
be cryptic (sensor.lumi_lumi_weather_7a8b2c_temperature).
Spend time upfront creating a clean mapping document for your agent.
“The living room temperature sensor” should resolve to the right entity
without ambiguity. This mapping file is arguably the most important
piece of the whole setup.
Network reliability. If your OpenClaw instance can’t
reach Home Assistant — network blip, DNS issue, whatever — your AI layer
goes silent. Your Home Assistant automations keep running (they’re
local), but the AI reasoning layer drops out. Design for graceful
degradation. The house should still function sensibly when the AI layer
is unavailable.
Where This Is Heading
The openclaw home assistant integration is really
just the beginning of what’s possible when you connect a reasoning AI
agent to a home automation platform. Today, it’s about smarter responses
to sensor data and natural language control. Tomorrow, it’s predictive
maintenance (your boiler’s energy signature has changed — it might need
servicing), genuine learning from your preferences without explicit
programming, and multi-home coordination for people managing
properties.
Clawdbot and moltbot are already capable of handling surprisingly
complex home reasoning when given the right tools and context. The setup
takes an afternoon. The tweaking and refining is ongoing — but that’s
half the fun. You’re not just configuring a system; you’re teaching an
agent about your home and how you live in it.
The smart home promise was always about a home that adapts to you.
With OpenClaw and Home Assistant working together, that promise is
finally starting to look real. Not perfect. Not magic. But genuinely,
practically useful in ways that rigid automation never quite
managed.
Start with one room. Get the API connected, give your agent some
sensor data, and let it manage lighting for a week. You’ll immediately
see the difference between a home that follows rules and one that
actually thinks.