A snapshot from May 2026. The tended, current-state version lives in the garden: my-ai-native-homelab.
06:45. The underblanket warms — quietly, fifteen minutes before the alarm. At 07:00 the lights fade in. The shutters open. The security system disarms. The front door unlocks. A voice in the bedroom starts speaking.
You can hear the voice take a breath. “Good morning. Twelve degrees, overcast, clearing by midday. You have a meeting at nine; the U6 toward Garching is on time, so leave at quarter past eight. It’s a bit stuffy; you may want to open the windows. I heard a great spotted woodpecker just after dawn.”
That’s not a script. It’s a fresh briefing every morning, written by an LLM.
07:00 wasn’t a fixed time for the alarm. A 09:00 meeting on my calendar carried a location. The system priced the transit, walked back to a leave time, then back another thirty minutes for the morning routine, and stopped at 07:00. The good-night briefing had read it back at the bedside: “The house is secure. Sleep well. I’ll wake you at seven — you have a meeting at nine.”
The morning is choreographed by deterministic rules — an autonomic nervous system. But the rules aren’t static. They adjust dynamically throughout the day to deliver the right information at the right time.
Everything described in this post is real. Every automation, every sensor pipeline, every agent workflow runs in production in my apartment in Munich. Nothing is hypothetical; nothing is a roadmap item.
The house is a robot
Rules that fire in milliseconds. Rules that sequence those rules into routines. Rules that get rewritten overnight. Three time scales, one architecture — and the architecture isn’t new. Robotics worked it out over twenty years before LLMs arrived: sense the world, plan against what you sense, act on the world. Sense-Plan-Act. SPA.
In the 1970s, Shakey the Robot ran the original SPA loop — sense the world, plan against a symbolic model, act, repeat. Classical and clean, but brittle when the world didn’t match the model. In 1986, Rodney Brooks flipped the script with subsumption architecture: layered behaviors coupling sensors directly to actuators, no central plan at all. Pure reactive control. Fast, but a robot with no deliberation can’t sequence anything more complex than wall-following.
The synthesis came in the 1990s with three-layer architectures — 3T. A fast reactive layer for immediate response, a mid-frequency executive layer of state machines that sequence reactive behaviors, and a slow deliberative layer that does the actual planning. The executive bridges the speed gap: it can’t think, but it can run hierarchical state machines that activate and deactivate reactive behaviors in a planned order.
My house is a literal 3T system:
- Reactive layer — Home Assistant’s deterministic automations. Motion triggers light. Leak triggers alarm. Milliseconds to seconds. The autonomic nervous system.
- Executive layer — HA’s blueprints and state machines. The alert lifecycle, the sleep routine, the circadian cascade, the calendar-driven wake-up alarm. Seconds to minutes.
- Deliberative layer — an Agentic OS. Claude Code agents reading a knowledge base of prior decisions, reasoning against the deterministic plane’s state, and writing the rules the lower two layers run. Minutes to hours.
Sensors flow into all three layers. The reactive and executive layers produce actuator commands directly. The deliberative layer changes the rules the lower layers follow — and every change is committed through git.
Sense
Sensors are how the world enters the system. The house has a lot of them, and the interesting part isn’t any individual sensor — it’s how many different kinds of data flow into the same automation engine.
Cameras watch entrances, doorways, and the package box. Smart-detect events (person, vehicle, package, animal) become HA binary sensors. A camera pointed at the front step runs a different pipeline — not a trained vision model, but a Gemini Vision call that decides whether a package is visible in the frame. Motion triggers the check; a periodic scan catches packages dropped silently when motion sensors miss them.
The garden cameras have microphones. BirdNET-Go reads RTSP audio streams and identifies 6,500+ species in real time. Detections publish over MQTT, and a daily aggregation feeds the morning briefing — “You had a great spotted woodpecker in the garden yesterday afternoon.” All this from cameras that were already there for security.
Bermuda BLE tracking uses ESPHome-flashed Shelly smart plugs as receivers, locating phones to room-level precision without a separate beacon network. Room-level presence fuses BLE, GPS, and the family calendar — a kid’s school event during school hours sets a synthetic “away” state even if the BLE tracker says they’re nearby.
The calendar is a sensor too. Events the household schedules are first-class inputs that the executive and deliberative tiers both read. A bespoke google_directions integration calls Google’s Routes API, parses hashtags from event text as travel metadata (#drive, #transit, #route U6, #early 15, #wakeup 06:30), and computes leave times. The hashtags are a DSL — event text becomes configuration.
Then the less glamorous sensors that keep the house safe: water leak detectors in five rooms, a radon monitor in the basement, CO2 and PM2.5 sensors in the bedrooms, pollen forecasts from an external API, Withings sleep mats under the mattresses, and Shelly plugs doing double duty as BLE receivers and energy monitors that detect washing-machine cycle completion via current draw.
Every one of these feeds the same automation engine.
Plan
The deterministic tiers
The reactive and executive tiers live in Home Assistant — about 40 YAML package files organized by domain. Lighting, climate, presence, sleep, alerts, shutters, each in its own file. AI never decides whether a light turns on or whether the alarm fires. The deterministic plane handles that.
The full HA architecture gets its own post. The short version: presence-activated circadian lighting in every room, per-room HVAC with DND awareness, a calendar-driven wake-up alarm that recomputes each evening from tomorrow’s family calendar events, and a custom alert stack built on a single blueprint instantiated dozens of times across safety, security, air quality, appliance, and pet-care domains.
The interesting parts are the systems that compose across packages. The circadian phase is one entity — input_select.circadian_phase — that every consumer reads: lighting blueprints, announcement macros, accent light schedules, the bed sensor’s nap-vs-bedtime distinction. Sleep is a master switch that sequences shutters, lights, locks, alarm arming, and wake-up evaluation in a single script. The calendar tag DSL turns family scheduling into travel-mode configuration without anyone touching HA’s UI.
These tiers are fast, predictable, and boring in the best sense. The sleep routine activates and deactivates reactive lighting rules in a planned order — the executive layer doing exactly what 3T designed it for.
The deliberative tier
The deliberative tier is where AI does the work. It’s an Agentic OS with three components:
- A control plane — Todoist Dispatch, a Python cron job that triages every task every 15 minutes and routes it to an agent. AI tasks and human tasks share the same lane, same triage engine, same comment thread. Two-inbox systems fail because the dividing line drifts — a task that starts as human investigation becomes AI diagnosis becomes AI fix becomes human review, and if those phases live in different systems, context is lost at every handoff.
- A memory — the Obsidian vault as PKM-RAG. Plans, agent definitions, postmortems, retrospectives, and per-agent memory files. The next agent reads existing notes before opening a new investigation. This is what makes diagnoses cumulative rather than rediscovered.
- An engine — Claude Code agents running on a dedicated LXC, connected to HA, Grafana, Proxmox, VictoriaLogs, and Todoist via MCP servers. A 10-step SDLC pipeline handles code changes with architecture review, TDD, parallel verification, mutation testing, and deployment gates.
The deliberative tier never directly turns on a light. It changes the rules the lower tiers run. When it writes a new YAML package or modifies a blueprint, the deterministic plane reloads, executes the new rules, and emits state and traces — which the deliberative tier can read again, possibly amending the vault with what was learned.
The agent pipeline, SDLC workflow, and Todoist Dispatch system each get their own post. The point here is the composition: the deliberative tier sits on top of the deterministic tiers, reads their state, writes their rules, and every change is a git commit that can be audited and reverted.
Act
Acting is where the house touches the physical world. Lights turn on. Doors unlock. The heat pump shifts setpoint. Shutters close. Phones buzz. Speakers speak.
Most actuation channels are straightforward — the rules were set in Plan, and Act is the deterministic moment the command lands. The distinctive surface is voice.
The house speaks through a bespoke integration that drives Gemini TTS to Sonos speakers. It replaced a popular HACS integration to solve three concrete problems: monolithic TTS timeouts on long messages, lossy audio re-encoding through pydub, and unbounded cache growth. The replacement streams raw PCM from Gemini’s API, wraps it in a WAV header, and plays it natively on Sonos via the AudioClip API — which ducks current music, plays the announcement, then auto-restores playback.
The integration routes announcements to the right room by resolving each person’s location via BLE, then mapping to the nearest Sonos speaker. It waits for natural gaps between music tracks when a track boundary is imminent. Morning briefings — AI-generated summaries of calendar, weather, system status, and curated news — get pre-warmed into the cache at 5 AM so the spoken delivery at wake time is instant.
“Charlotte, you should leave for school in 10 minutes — the U6 toward Garching is at half past.”
That sentence pulls from three systems: the calendar integration computed the leave time, the Routes API identified the transit line, and the presence system targeted the announcement to Charlotte’s current room. Plan decided what to say. Act said it.
Repeat
The opening was the loop running smoothly — calendar to leave-time to bed warmer to briefing, on a typical morning. The middle sections built the machinery: sensors that observe, deterministic rules that decide, an AI tier that writes the rules, channels that act. This closing section shows the loop catching harder problems — the postmortems where the system finds its own bugs.
The vault has 70+ postmortems, written by the root-cause agent each time something breaks. Each follows the same template. The root-cause agent reads the existing archive before opening a new investigation. The interesting pattern isn’t any one bug — it’s how the system catches itself.
The shutter that was closed in state but open in reality
The office shutter was found physically open one morning. Home Assistant said it had been closed overnight. Both were correct.
The Becker shutter integration uses one-way RF over a single USB serial transceiver and tracks position purely by elapsed travel time — no physical feedback. Two concurrent automation chains both sent close commands when the house entered sleep mode. Chain A — the sleep shutter script with deliberate 1-second stagger delays between RF commands — sent the master bedroom close at 23:35:11.440. Chain B — a sync automation that propagates sleep state to the office — sent the office close at 23:35:11.538.
98 milliseconds apart on the same USB transceiver. RF collision. The office command was dropped. The integration, with no feedback channel, reported the shutter as closed after simulating the 30.5-second travel time. The shutter never moved.
The 1-second stagger was the correct mitigation — but it only protected commands inside the sleep script. The office close lived on a separate code path, hidden behind a sync automation that nobody had connected to the RF-serialization constraint.
The fix consolidated every Becker command into the sleep and wake-up scripts, removing the parallel paths. The architectural finding — “sync automations create hidden coupling; downstream effects need to be sequenced with other concurrent actions” — went into the architect agent’s memory.
Package detection: three rounds, three failure modes
The package detection system iterated through three failure modes in twelve days:
Round 1 — input_boolean.package_detected got stuck on after an AI call failure. The automation aborted before reaching its state-clearing logic. Fix: explicit failure handling.
Round 2 — Gemini started returning systemic false positives on IR night-vision images. The prompt was overcorrected to describe permanent items to ignore.
Round 3 — A missed package. The motion fired, the AI ran, but the Round 2 prompt overcorrection had taught Gemini to classify real packages as “permanent items.” Worse, the proactive periodic scan only ran when package_detected was already on — so there was no recovery path for false negatives.
Three rounds, three different root causes, one pipeline. The shape that emerged: every detection branch needs both a positive and a negative recovery path. The proactive scan was restructured to run independently of current detection state.
The water-leak alerts that weren’t
This story matters less for the bug than for what diagnosing it required.
Four critical “Health Alert” notifications fire after an HA restart: “Monitored entity binary_sensor.alert_kitchen_water_leak not available after startup.” No water anywhere. But the notifications hit notify.critical with a 1-minute repeat — the highest-priority channel in the house.
The root-cause agent doesn’t start from scratch. It reads the vault’s prior alert postmortems first. Three existing postmortems cover the same blueprint’s startup behavior — a premature evaluation race, a tri-state migration issue, and an acknowledged-state persistence fix. With those loaded, the agent traces the new failure in minutes.
The Aqara leak sensors only publish the water_leak MQTT property on state-change events. After a restart, heartbeat reports include battery and temperature — but never water_leak. The sensor stays unknown indefinitely. A prior fix had added availability templates to keep alert sensors unavailable until the underlying entity has a value. The blueprint’s 60-second startup wait expires. The timeout path fires notify.critical.
The previous fix didn’t break the system. It uncovered a new failure mode by closing one race only to expose the next one — exactly the shape PKM-RAG is meant to surface.
Without the postmortem chain, the agent would have re-derived the entire blueprint history from logs and source code. With the chain, the trace from “false-positive leak alert” to “Aqara firmware doesn’t include water_leak in heartbeats” took minutes.
The architect’s memory gained a new pattern: “a fix that adds an availability guard creates a new dependency on the underlying entity ever having a value. Sensors that only report on state change can deadlock the guard.”
Why these stories matter
Three properties make the postmortems work:
- Diagnosis is separated from fix. The root-cause agent only diagnoses; the SDLC pipeline writes the fix. The agent that finds the problem isn’t the agent that writes the code.
- Postmortems live in the vault. The next root-cause agent reads them before opening a new investigation. The retro agent reads recurring shapes across postmortems and updates its own memory.
- Findings change the rules. Every postmortem yields code changes and memory updates. The deterministic plane and the AI plane both learn.
The system compounds. Each investigation makes the next one faster and more precise — not because the agents get smarter, but because the memory gets deeper.
The deterministic plane runs the house. The AI plane writes the deterministic plane. The human sets intent — through Todoist tasks, vault notes, and calendar events.
Every loop closes through code in git.