From Tomato to Groovy to Citadel

There is a point in every homelab where you realize the system running today did not begin with a grand architecture diagram.

It began with one little problem. Then another. Then one Saturday afternoon disappeared. Then another Saturday disappeared because the solution from the first Saturday needed monitoring.

Eventually you have routers, switches, dashboards, radios, APIs, automations, backup jobs, and very strong opinions about whether a light switch should need access to the public internet.

That is more or less how I got here.

Today my home infrastructure is called Citadel. Home Assistant is the automation backend. HomeAuto, part of Project Kaizen, sits above it as my own governed control and intelligence layer. Z-Wave, Zigbee, cameras, HVAC, lighting, security, robots, dashboards, and notifications have collapsed into one coherent architecture.

It feels fast. It feels clean. It feels almost obvious. Getting here was anything but.

It Started with a Router

Before home automation, I was already doing the thing that leads to home automation: taking perfectly functional consumer hardware and replacing the software because functional was not interesting enough.

If you were around for DD-WRT and Tomato, you know the feeling. Those projects turned ordinary consumer routers into little network laboratories. Better routing. VPN support. Bandwidth graphs. DNS controls. Quality of service settings that could consume an entire evening before you realized you had improved absolutely nothing.

At one point I had Tomato running on a Netgear Nighthawk. I loved that router. I also worked the poor thing half to death, running tasks that had no business being on a consumer router. Eventually that little processor was doing everything except asking for overtime pay.

But something important happened during that period. I stopped seeing appliances and started seeing systems. If hardware exposed enough access, and software could talk to it, then the boundaries shipped by the manufacturer were only suggestions. That idea became foundational to everything that followed.

The Synology Years

Around the same time, the Synology NAS taught the same lesson from another angle. A device could be more than the category printed on the box: a NAS could store files, but it could also host applications, run backups, serve media, and quietly become infrastructure. The house was developing layers. Then the smart-home explosion arrived with a completely different kind of problem.

The First Promise of SmartThings

In the middle of the 2010s, everybody suddenly wanted to automate the home. Samsung had SmartThings. Apple had HomeKit. Amazon had Alexa. Z-Wave, Zigbee, Wi-Fi devices, proprietary clouds. Everybody was building the future. Nobody had agreed on what the future was.

I started with SmartThings, and for a while it was magic: a sensor from one company, a switch from another, and suddenly a door opening turned on a light. But the magic lived inside a fragmented ecosystem. Integrations worked today and disappeared tomorrow. An automation that should have been instant took seconds, because the event had to leave the house, travel through somebody else's server, and return with permission to turn on a lamp ten feet away.

SmartThings showed me what the connected home could become. It also showed me the wall. I did not need another smart device. I needed a translation layer.

Hubitat Took the Gamble

That is why I fell in love with Hubitat. Not Samsung, not Apple, not Amazon: a small engineering company walking into a market of giants. It could not win on cloud scale or marketing, so it made a different bet. Give power users control. Local execution, open integrations, Maker API, community drivers, and an automation engine that let determined people build almost anything. It trusted the user. It was right.

The community driver ecosystem was the magic. If a manufacturer did not support the platform, somebody would reverse engineer the protocol and write a Groovy driver. And yes, an entire era of my house ran on a programming language named Groovy, which described the situation perfectly. A forum thread would grow to forty pages, and a device that officially belonged to another ecosystem would quietly begin operating inside Hubitat. The house did not have to follow the manufacturers' boundaries.

Then there was Rule Machine. It could feel like programming an industrial controller through a web interface designed by somebody who believed visual comfort encouraged weakness. But it was powerful: triggers, conditions, variables, nested logic, rules that paused other rules, rules that existed mainly to repair the consequences of earlier rules. Sometimes elegant, sometimes automation spaghetti. But it was yours.

And there was Maker API, maybe the feature that mattered most to what Citadel became. Maker API meant Hubitat did not have to be the experience. It could simply be the machinery, and my software could talk to it through a common interface. That idea never left me: the backend should understand the devices, the frontend should understand the human.

SharpTools Made the Machinery Disappear

SharpTools completed the picture from the opposite direction. It did not own the hub or the radios; it treated the backend as infrastructure and made the experience good. Hubitat was the engine room, SharpTools was the bridge, and a wall-mounted tablet turned a pile of drivers, virtual switches, and Rule Machine logic into something that felt like a finished product.

That was the cocktail. Hubitat on the backend. SharpTools on the front. It felt years ahead of the manufacturer apps, and it proved something important: the backend and the frontend do not have to be the same system.

Both companies deserve flowers. They bet there were enough of us who cared about APIs, local processing, and custom dashboards, and they were right. Life360 added location as automation data, and naturally I spent hours getting it onto a SharpTools panel, because that is how these hobbies work. You save three seconds and invest six hours achieving it. Completely rational.

The Bridges Kept Multiplying

For years the system worked, and I want to be clear about that. But the workarounds accumulated. Drivers broke. Cloud APIs changed. Virtual devices manipulated other virtual devices that represented something physical somewhere else. Homebridge joined as another translation layer, enormously useful for giving Apple devices access to unsupported hardware, and also another runtime, another plugin ecosystem, another place where state could drift.

Device to Hubitat. Hubitat to Homebridge. Homebridge to Apple Home. Hubitat to SharpTools. It all worked. But eventually I had built enough bridges that I started wondering why there was still a river.

That is not a criticism of any product. Every new layer solves a problem. Then the collection of layers becomes the next problem.

Then I Finally Gave Home Assistant a Serious Look

The funny part: Home Assistant had been there the whole time. But I had a system that worked, and migrating a working home is the sort of project that sounds fun until you remember that actual doors, cameras, and alarms are attached to it.

Then I installed Home Assistant on a Raspberry Pi 5, and almost immediately had the feeling. This is different. Snappy. Entities made sense. Diagnostics made sense. Z-Wave JS felt like a modern radio stack. Ecobee, Govee, UniFi Protect, the Roombas, HomeKit: they all just came in. I was no longer inventing glue for every integration. The platform itself was the glue.

Today that Pi runs Home Assistant, the Z-Wave stack, Zigbee, DNS for the whole network, and four hundred days of device history on local NVMe, and it barely seems to care. One small ARM computer operates a huge portion of the house.

What HomeAuto Actually Does

The real change was not swapping Hubitat for Home Assistant. It was finally naming what each layer is for. Home Assistant is the nervous system: it knows the devices, normalizes the entities, maintains state. Above it sits HomeAuto, the governed brain, and the part I am proudest of.

It governs every action. No browser, dashboard, or AI talks directly to Home Assistant or the alarm panel. Everything goes through HomeAuto, and every control action creates a confirmation challenge only the same operator can approve. An AI suggestion and a human click travel the same governed path, so the AI can never do anything the human could not.

It owns the security posture. The Honeywell alarm panel enters through a dedicated local bridge, with disarm gated behind multiple independent layers. The dashboard shows the live panel the way an operator would want it: zone-by-zone reporting, bypasses, trouble flags. Not a cartoon shield icon. Evidence.

It watches with intent. The cameras run person-only smart detection, applied as deliberate policy, with smoke and CO listening kept on because life safety is never muted.

It speaks. An announcement engine decides what the house says out loud and when, through the Alexa speakers built into the Ecobee thermostats on every floor. Routine announcements respect quiet hours. Life-safety announcements are exempt, always.

It remembers. Four hundred days of device history feed bounded, read-only analysis. The house has a memory, and the memory stays home.

It talks to an AI that lives here. Max runs on local hardware in this house and touches the home only through HomeAuto's governed interfaces. Not a single byte of my home's state leaves the building. The intelligence layer is a resident, not a tenant of somebody's cloud.

The Day the Box Went Dark

For months the Hubitat C-8 Pro kept running while the migration proceeded the only way security migrations should: every device proven on the new platform, rollback paths intact. Ecobee moved. Govee moved. Roomba, the cameras, Z-Wave with its radio, Zigbee, the locks, the garage, Apple Home. And then, on August 25, 2026, there was nothing left for Hubitat to do.

I made the final backup. I archived the drivers, the rules, and the device history. And I shut the box down. I did smile. Because it earned that.

Retirement is not rejection. Hubitat was the right answer to the SmartThings problem; Home Assistant is the stronger answer to the problem as it exists today. Back then, Hubitat felt liberating compared with SmartThings. Today, Home Assistant feels liberating compared with Hubitat. Both are true.

Max Stands Watch

Here is where it gets interesting, because the newest phase is no longer a roadmap item. It is on duty tonight.

A person-detection event used to be a fact. Person detected, side yard. Useful, but a fact without judgment. Today that fact goes straight to Max, the local reasoning model, along with everything the house already knows.

Max does not just forward alerts. Max ranks them. A courier at the front door at 2 PM while I am home is noise. A person lingering in the side yard at midnight is a threat assessment. And when the assessment says a life may be at stake, the escalation has one goal that I find genuinely moving to have designed into a machine: the system wants to confirm my safety and wellbeing.

Here is how it plays out. 11:52 on a Tuesday night. The house is armed stay. I am asleep upstairs. The side yard camera reports a person, and Max does what a guard does, not what a motion sensor does. It watches. Two minutes. Three. The person is not passing through. They are lingering, working along the fence line, checking the windows. Max holds them in frame the whole time, with the context the house already owns: armed stay, midnight, everyone home, and four hundred days of history that say nobody has ever had business in the side yard at this hour.

Threat level: elevated. My phone gets a quiet push with the snapshot. No sirens, no drama. Max keeps watching.

Then two things happen eleven seconds apart. The vision reasoning catches a frame it does not like: the object in the person's hand has the profile of a weapon. And the back door zone breaks. The panel, armed stay, trips instantly. Siren. This is no longer surveillance. An armed intruder has entered the house while I am asleep upstairs, and Max's assessment jumps to the highest severity it has: human life in danger.

At that severity there is no polite ladder. Every channel fires at once. The speakers on every floor announce what is happening and where, waking me with the exact part of the house to avoid:

"Attention. This is Max. The alarm has been triggered. An intruder tracked in the side yard has breached the back door and may be armed. Shawn, stay upstairs and away from the stairs. The authorities have been notified."

In the same moment: the push with the evidence attached, the SMS, and my phone ringing:

"This is Max. A break-in is in progress at the back door. The intruder was tracked in the side yard for three minutes and appears to be armed. The alarm is sounding. Please confirm you are safe."

And it keeps calling until it gets that confirmation, because during a break-in an unacknowledged alert is an open question about whether the person inside is okay.

Lower severities climb the ladder one rung at a time: announce, push, SMS, call, each waiting for acknowledgment. A confirmed threat to human life waits for nothing. Every layer runs in the platform: the announcement engine, the push channel, the SMS and voice-call lanes, the delivery receipts, and the alarm panel feed that lets a camera track and a zone breach fuse into a single judgment. Max reasons and speaks freely; every hard action stays behind the same gates as everyone else. That governance is the entire reason I am comfortable wiring a reasoning model into my home's security.

Further Out: The House That Answers Back

The bench behind that has more on it. All of it follows from the same architecture.

Max talks to the intruder. The cameras have speakers and live streams, so the ladder does not have to stop at my phone. While my phone is ringing, the camera itself can speak, calm and articulate:

"You are standing in the side yard of a monitored property. I am the security intelligence for this house. I can see you. I have been recording since you arrived. The owner and the authorities have already been notified."

Not a barking-dog sound effect. A system demonstrating awareness, describing where they stand, in real time. A recorded deterrent is ignorable. A conversation is unsettling in exactly the right way.

Cross-camera tracking. One person moving across the property should be one story, stitched across cameras into a narrative timeline, not a pile of disconnected pings.

Evidence packets. A local vision model describes the build, the clothing, the behavior, then attaches stills, the clip, and a written narrative. By the time I look at my phone, the report is already written.

Deterrence choreography. Floodlights on, porch lighting shifting to red, the house visibly waking up. Nothing says you have been noticed like a building changing its posture around you.

Anomaly baselines. Four hundred days of history means the house can score deviation instead of matching rules. The 2 AM garage door is not suspicious because a rule says so. It is suspicious because it has never once happened before.

The trusted-contact ladder. If I truly cannot be reached, the system should know who to try next. Escalation should never dead-end at one phone.

Same Obsession, Better Architecture

Looking backward, there is a straight line through all of it. Tomato taught me hardware is not limited by the software it ships with. Hubitat taught me local execution and open control. Rule Machine taught me raw capability beats polished simplicity. Maker API taught me to separate the machine interface from the human interface. SharpTools showed me a clean frontend above complicated infrastructure. Homebridge showed me how valuable translation layers are, and how quickly they multiply. Home Assistant brought the lessons under one roof. Project Kaizen added the intelligence. HomeAuto added the governance. Citadel connected it all.

At the beginning I wanted more control out of a router. Then devices that cooperated. Then local execution, APIs, one system for cameras, lighting, security, and voice. Then AI in the house without uncontrolled access. Now the house reasons about what it sees and refuses to rest until it knows I am safe.

The projects changed. The obsession stayed the same. Make incompatible things behave like one system.

The system today is cleaner, faster, more local, and more capable than anything I had before. But it stands on every strange driver, every Maker API call, every SharpTools tile, every late night spent asking whether a consumer device could be persuaded to do one more thing. The little companies mattered. The forum users writing drivers for devices they did not manufacture mattered. Hubitat and SharpTools took a gamble on people like me, and they earned their place in this story.

And the Hubitat box was not thrown away as a failed experiment. It was retired as a machine that completed its mission.

That little Nighthawk running Tomato would probably be terrified of what it started.

I think it would also be proud.