I Gave My Homelab a Brain

Most homelabs are a pile of self-hosted services. Mine started that way too: photos, music, a password manager, the usual. The part I actually find interesting is what I built on top — a fleet of AI agents that operate the cluster, coach my training, review my startup’s code while I sleep, and run my weekly review, all reading and writing a single self-hosted memory.

Here’s how it fits together.

The hardware

Three machines on a Tailscale mesh:

dom — a small, always-on mini-PC that hosts everything in Docker.
a Raspberry Pi — network-wide DNS.
fugaku — an RTX 3070 desktop that’s only on sometimes. It’s the GPU when I need one (photo ML, embeddings) and the agents fall back to CPU when it’s off.

Nothing exotic. The interesting part isn’t the metal.

A fleet of agents, not a chatbot

On dom I run Hermes, an open-source agent runtime, and I’ve written a set of custom skills on top of it. Each skill is an agent with a job, a schedule, and a Telegram channel it talks to me through:

workout-coach — reads my training log, keeps my plan synced to Google Calendar, pulls my Whoop recovery data each morning, and runs a Sunday review that tells me whether I’m under-recovered or just under-training.
a nightly code reviewer for my startup — every night it picks the most-active repo across our codebase, reviews the day’s commits, writes its findings to a file, and pings me a one-line summary. Security issues get a 🚨. I wake up to a digest of what changed and what’s worth a second look.
a weekly reflection agent — runs a Saturday review and Sunday plan over my personal notes (a plain-markdown Obsidian vault), then “gardens” the note graph: surfacing orphans, proposing links, keeping it healthy. It augments the habit; it doesn’t replace it.

None of these is a toy. The code reviewer is leverage on my actual company. The training coach changed how I program my weeks. They run whether or not I’m at a keyboard.

The part I’m proudest of: a shared brain

Agents are only as good as what they remember. So both my laptop’s coding agent (Claude Code) and the server’s Hermes agent read and write one shared memory — a self-hosted temporal knowledge graph.

It’s Graphiti running on FalkorDB, with a local embedding model so the content never leaves the box, exposed over an MCP server that both agents reach over the mesh. I had to patch the upstream image in a couple of places to make it work for this setup. Memories are namespaced — one space for infrastructure and ops, one for the personal stuff — so the two domains stay separate while living in the same store.

The effect is small but it changes everything: a fact one agent learns, the other can recall. When I fix something on the server from my laptop, the server’s agent already knows about it the next time it runs. The system feels like one mind instead of a dozen disconnected scripts.

The homelab runs itself — through an agent

Here’s the loop I think is actually novel. I don’t administer this cluster by hand. I administer it through Claude Code: I describe what I want, it does the work over SSH, and every change is recorded in an append-only changelog — more than 50 revisions deep now.

That log turned out to be honest in a way I didn’t plan for. When a cleanup script the agent ran over-matched and deleted some memories it shouldn’t have, the next pass caught it from a sudden drop in node count, restored them from backup, and wrote down exactly what happened and why. I’ve since made “200% verification” the house rule: exercise a change end-to-end — survive a full restart, confirm the data’s actually there — rather than just status-checking it. Operating real infrastructure this way, with an agent and a paper trail, has taught me more about building reliable agentic systems than any amount of demoware.

Smaller things I ship for fun

Not everything is infrastructure. I also build small web apps:

bucketlist.dev-simon.com — a little Next.js + SQLite app for keeping a shared list of things to do.
an interactive road-trip map for a trip with friends.

More at github.com/Oldault and dev-simon.com.

Why I build this way

I’m building an AI product, TailorLead, and the homelab is where I get my hands dirty with the primitives I care about commercially: agent orchestration, persistent memory, scheduling, and the long gap between “the demo works” and “it’s run unattended for months.” It’s the cheapest R&D lab I could ask for — real uptime, real data, real consequences, and zero stakes when something breaks.

So the honest version of what did you build in your spare time is this: I gave my homelab a brain, pointed a few agents at the parts of my life and work where I wanted leverage, and let them run. The avocados, so far, are paying for themselves.

Stack: Docker · Tailscale · Hermes (Nous Research) · Claude Code · Graphiti + FalkorDB · Ollama (local embeddings) · Syncthing · Cloudflare Tunnel · Next.js. Three hosts, one shared memory, no open ports.