This house has a brain, and it forgets on purpose

Your smart speaker executes commands. This thing understands intent, and the gap between those two sentences is the whole sighting.

Ziggy is a home AI assistant built by one engineer, and instead of the usual chatbot-with-plugins shape, it is architected like a biological brain. The writeup names the parts like a neurology textbook and then shows you the stack behind each one.

Five regions, each with a job

Requests hit a triage agent that routes like a prefrontal lobe deciding which region handles the job. The metaphor is load-bearing: every request enters through that agent, and nothing reaches a deeper system without being routed first.

Routing-first is a real architectural decision, not garnish. "Turn off the kitchen lights" should never wake the memory graph, and "what did I say about the furnace last winter" should never touch a light switch. One cheap classification up front keeps every deeper system small, single-purpose, and testable on its own.

Behind it sit four more regions. A motor cortex of tool servers drives the physical house, lights, climate, anything on the network. A hippocampus holds long-term memory. A cerebellum, in practice a cron-driven scheduler, handles recurring automation. A temporal lobe sends notifications and check-ins over SMS.

The SMS detail is easy to skim past and should not be. A house that can text you is a house that can start conversations, not just answer them: the cerebellum fires a scheduled check-in, the temporal lobe delivers it, and suddenly the assistant has initiative. Every commercial speaker on the market waits to be spoken to.

The builder's degree mixes psychology and neuroscience; the day job is distributed systems. The brain diagram is not decoration. It is autobiography.

The stack under the metaphor

FastAPI serves the backend. Haystack orchestrates the multi-agent routing, with Anthropic models doing the reasoning at each step. The tool layer speaks the Model Context Protocol, the open standard for wiring AI systems to external tools, through FastMCP servers, and three of Ziggy's MCP servers are purpose-built: one for the memory graph, one for scheduling, one for SMS.

Speaking MCP instead of a homemade plugin format is a quietly big bet. It means each of those three servers is a standalone service any MCP-speaking client could connect to tomorrow, and the house's organs stay usable even if the brain around them gets rebuilt. The tool layer outliving the orchestrator is the kind of decoupling platform teams write RFCs about.

Conversations persist to MongoDB. A Next.js client streams answers over WebSocket and shows which cortex is working while you wait. Every model call is traced through Opik, with the logs landing in an ELK stack, so a bad answer is a debuggable event instead of a mystery. This is a hobby project instrumented like a bank.

The writeup's position on all this instrumentation is the part worth stealing. Real personalization, it argues, is not a clever system prompt; it is memory, retrieval, evaluation, identity, observability, and a data lifecycle, designed in as foundations from the first commit. Most assistant demos bolt a chat model onto an API and call it personal. This one treats the chat model as the smallest part.

It is also stateless enough to run almost anywhere: AWS Lambda, Azure Container Apps, or a few pods on the builder's own five-node k3s cluster, the same scavenged-hardware machine from the datacenter in the hallway. It runs on that cluster today, next to the rest of the house's infrastructure.

Memory that forgets on purpose

The part that made me put my coffee down. Ziggy remembers with a Neo4j graph plus embeddings, and every conversation moves through three stages. First a summary: a title under ten words, a body under 250. Then consolidation: episodic memories, what happened, and semantic memories, what is true, get extracted and linked into the graph, threaded back to the conversation that produced them. Then, deliberately, forgetting. Stale information gets pruned, and the pruning leaves an audit trail of what was removed and why.

Those size caps are doing real work. A title under ten words is a retrieval key, not a paragraph, and a 250-word ceiling forces every memory to commit to what actually mattered about the conversation. Embeddings over tight summaries find the right memory; embeddings over raw transcripts find twelve wrong ones that mention the same nouns.

The episodic-versus-semantic split is textbook cognitive science made operational. What happened last Tuesday and what is generally true about this household are different data with different decay rates, and storing them as linked but separate node types is what makes a principled forgetting policy possible at all.

Most chat memory is a transcript, and a graph that only grows becomes noise. A home assistant with a documented forgetting policy is a sentence I did not expect to type this year. Most billion-dollar products cannot tell you what they remember about you. This one can tell you what it chose to stop remembering, and when.

And the forgetting is framed as deprioritization with receipts rather than deletion. The distinction matters for a machine that lives with you: episodic memories of one Tuesday should fade, the semantic fact that you hate overhead lighting should not, and the graph structure is what lets the pruning tell those apart.

The neighbors, counted

To see how unusual this architecture is, look at the scene around it. Home Assistant, the reigning open-source home hub, reports 692,346 active installations on its public analytics page, and that only counts the under-a-quarter of users who opt in to reporting. Nearly all of those houses run on the executes-commands model: triggers, conditions, actions, written out by hand.

Ziggy is not competing with that fleet; it sits a layer above it, where almost nobody lives yet. The layer is arriving fast, though. Graphiti, an open-source framework for exactly the kind of real-time knowledge graph Ziggy builds by hand in Neo4j, has climbed to 31,385 GitHub stars on the strength of agent builders hitting the same wall: a transcript is not a memory.

So the two halves of this build each have a crowd, the home-automation crowd and the agent-memory crowd. The sighting is one engineer standing in the overlap, which is still nearly empty.

What runs today, and what is still on paper

The routing, the memory pipeline, the MCP tool layer, and the device control all run now. A visual cortex is still on paper: SR501 presence sensors, so the house knows who is in the room rather than just what they typed. The SR501 is a passive infrared motion sensor that sells for about the price of a coffee, which is very much in the spirit of the cluster of rescued laptops it would plug into.

Splitting each cortex into its own container is the other open item, for blast-radius reasons, once more of the house depends on this staying up. Right now a bad deploy takes down the whole brain; containerized lobes would mean the lights keep answering while the memory graph reboots. The brain metaphor is still growing new lobes.

The design line that sums it up comes straight from the writeup: understand intent, not follow commands.

One person built this, wrote it up, and put the reasoning where anyone can check it. That is the kind of thing this site exists to point at. Go read the full home automation build writeup. If you want to try the routing pattern yourself, Haystack's own tutorials walk through building a tool-calling agent and then a multi-agent system, which is exactly the shape of Ziggy's front door. Pair that with one small MCP server for something your house can actually do, and you have the prefrontal lobe and one finger of the motor cortex in a weekend. And the same builder once handed an AI the doors on purpose, as a game: the AI runs the doors.

The house is thinking.