The house runs itself the same way every morning. And every night, it can rewrite how it runs.
Those two sentences are in tension — a system deterministic enough to trust with the locks and the alarm, and adaptive enough that an AI edits its own behavior while everyone sleeps. Resolving that tension is the entire architecture, and the resolution has a shape robotics settled on decades ago: a deterministic machine that acts, a slower planner that changes what the machine does, and a hard wall between them.
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 the twenty years before large language models arrived: sense the world, plan against what you sense, act on the world, repeat. Sense-Plan-Act. SPA.
That loop is the spine of the whole system:
- Sense — sensors are how the world enters the house: cameras, the network itself, microphones, leak and air-quality sensors, room-level presence, and the household calendar as a first-class input.
- Plan — three tiers decide what to do, at three different speeds.
- Act — the house touches the physical world: lights, locks, heating, shutters, notifications, speech.
- Repeat — the loop catches itself. Failures become written postmortems, postmortems become rule changes, and the next pass runs on the amended rules.
Everything below is one elaboration of that loop.
A lineage worth borrowing
The three-tier split at the center of this isn’t a clever invention. It’s the architecture robotics converged on over two decades, and the house adopts it on purpose.
- Classical Sense-Plan-Act (1970s–80s). Shakey the Robot and the STRIPS planner. Three sequential phases — sense, plan against a symbolic model of the world, act — then loop. Clean, and brittle the moment the world stopped matching the model.
- Subsumption (1986). Rodney Brooks’ reaction against pure planning: layered behaviors wiring sensors straight to actuators, with no central plan at all. Fast and hard to break, but a robot that can’t deliberate can’t sequence anything complex.
- Hybrid three-layer, or 3T (1990s). The synthesis. Split the agent into three tiers running at different speeds — a fast reactive layer (Brooks’ insight), a mid-frequency executive layer of state machines that sequence reactive skills, and a slow deliberative layer that does the actual planning. The executive bridges the gap: it can’t think, but it runs state machines that switch reactive behaviors on and off in a planned order.
- ReAct (2022). Language models interleaving reasoning with action. It doesn’t cite the robotics work, but the lineage is visible — it’s the deliberative layer modernized, with symbolic search swapped for a language model and reasoning made cheap enough to interleave with acting.
The house is a literal 3T system with a language model in the deliberative tier.
Three tiers, three time scales
The Plan stage is those three tiers, and the thing that separates them is how fast they run and what they’re allowed to change.
| Tier | Time scale | What it does | What it changes |
|---|---|---|---|
| Reactive | ms–s | Motion turns on a light; a leak trips the alarm. The autonomic nervous system. | Actuators, directly |
| Executive | s–min | The alert lifecycle, the sleep routine, the circadian cascade, the calendar-driven wake-up. Sequences reactive rules in a planned order. | Actuators, through sequenced reactive rules |
| Deliberative | min–hr, and overnight | Reads the deterministic plane’s state, reasons against a memory of prior decisions, and writes the rules the lower two tiers run. | The rules themselves, committed through git |
The mnemonic is three kinds of rule: rules that fire in milliseconds, rules that sequence those rules into routines, and rules that get rewritten overnight. Sensors flow into all three tiers. The bottom two emit commands to actuators directly. The top one changes what rules exist — never a light or a lock directly.
That last clause is the load-bearing one, and it gets its own section below.
Two planes, one hard boundary
Group the three tiers and they fall into two planes.
The autonomic plane
The reactive and executive tiers together. Everything the house does the same way every time lives here — presence-activated lighting, per-room heating with rate limits, a sleep routine that closes shutters and arms the alarm in sequence, an alert system built from a single blueprint stamped out dozens of times and backed by state that survives a restart. It runs on a deterministic home-automation platform as a few dozen configuration files organized by domain.
The defining property: AI never decides whether a light turns on or whether the alarm fires. The plane is fast, predictable, and auditable. Its state — every device, every automation trace, every log line — is readable by the plane above it.
A single shared value threads through it. One circadian phase — morning, day, evening, wind-down, night — is computed once and read by every consumer: the lighting, the spoken announcements, the accent-light schedules, the bed sensor’s nap-versus-bedtime call. Compose that way and a behavior change is a one-line change in one place.
The deliberative plane
The deliberative tier, and the interesting one. It reads the autonomic plane’s state, reasons against a memory of every prior decision, and writes new configuration — automation files, reusable blueprints, small custom integrations — that becomes the autonomic plane’s new rules. It rests on three co-equal enablers, and pulling any one collapses it:
- A control plane. A task queue that a scheduled job triages on a fixed interval and routes to an agent. Human tasks and AI tasks share one lane, one triage engine, one comment thread; retry and dead-letter handling are built in. 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 tools, context leaks at every handoff.
- A memory. A personal knowledge base used as a retrieval surface — plans, research notes, agent definitions, postmortems, retrospectives, per-agent memory files. The next agent reads what’s already written before opening a new investigation. That’s what makes diagnosis cumulative instead of rediscovered.
- An engine. Coding agents on always-on compute, wired to the rest of the house through tool servers, with code changes landing on disk and syncing out from there. A multi-step pipeline handles those changes with architecture review, test-first development, parallel review, mutation testing, and deployment gates.
The plane produces content as well as code — a morning-briefing pipeline that collects, filters, scores, and delivers is the same machinery pointed at words instead of rules.
The boundary rule
Here is the line the whole design is organized around.
The deliberative plane never actuates directly. It changes the rules the autonomic plane runs; the autonomic plane executes them. The fast path stays deterministic. The slow path stays auditable. A language model is never in the loop between “motion detected” and “light on” — it is only ever in the loop that decides what the motion rule should be in the first place.
The human sits above both planes, setting intent through tasks, notes, and calendar events, and holding onto the taste and judgment that neither plane has.
How the planes compose
The loop closes through git.
Autonomic plane emits state and traces (entities, automation traces, logs)
→ deliberative plane reads that state
→ reasons against its memory (plans, postmortems, prior decisions)
→ writes new configuration and code — the new rules
→ commits through git
→ autonomic plane reloads and runs the new rules
→ emits new state and traces → (loop)Because every rule change is a commit, nothing the AI does is invisible to the history. The system is auditable and reproducible by construction — a bad change is a line you can read and a line you can revert. Postmortems are one shape this loop takes; briefings, routine dispatches, and configuration changes are others. The compounding is the point: agents reading prior postmortems before diagnosing, retros recognizing a recurring shape, an architect’s memory accreting patterns learned the hard way. Enough of that and a hundred isolated investigations become one cumulative one.
The glue at the edges is disposable now
One architectural call runs through the whole build. Broad-surface foundations stay open source — the home-automation platform, the virtualization layer, the sync and the networking. But the integration glue at the edges has flipped. When an agent can produce a tested, focused integration in a weekend, the calculus that favored generic wrappers inverts: a purpose-built component aimed at one API and one device family is shorter, faster, and easier to debug than a general one that supports everything and gets used for one thing.
Two examples carry it. The house speaks through a bespoke text-to-speech integration that streams Gemini TTS straight to the Sonos speakers, replacing a general-purpose wrapper that timed out on long messages and re-encoded audio it didn’t need to. And the calendar drives travel and wake-up times through a bespoke google_directions integration that pairs Google’s Routes API with a small hashtag language — event text becomes configuration — replacing a generic travel-time add-on that only ever returned a duration. Open source still wins where the surface is broad. At the edges, the wrappers became disposable.
The deterministic plane runs the house. The AI plane writes the deterministic plane. The human sets intent and keeps the judgment. And every change the AI makes is a line in git — which is the only reason it’s safe to let it write the rules at all.