What I’m building on a headless Mac Mini

In its first week I pulled the Mac Mini’s power cord out mid-operation to see what would happen. It came back in about five seconds, logged itself in, rejoined its network, and sat there waiting for instructions. Nobody had to walk over to it, which is the whole point of a machine with no monitor, no keyboard, and a dummy plug where a display should be.

That test gets its own post later. The first post in this series sketched what the box holds. This one is the detail: who the agents are, what runs where, and the long list of things I decided not to build.

Four personas, in the order I planned to wake them. @kAI, the PM and concierge, the default face of the system and the one I message when I want anything at all. @siftr, the curator, who takes whatever I throw at it (a link, a repo, a half-formed note) and assesses it, connects it to what I’ve shared before, and decides where it goes. @ops, who looks after the Mini and the setup. And @dev, which is Claude Code: the builder, the one that writes and ships the code.

They aren’t personalities painted on one assistant. They’re four separate profiles, and the reason for that is half of why this project exists at all.

why/

Thirteen years of enterprise UX taught me what good tooling feels like from the design side. For the past while I’ve been building things solo with AI instead, and one pattern kept repeating until it annoyed me into this project: every conversation is an island. I’d load context into one chat, lose it, load it again into the next. The tools have memory features now, but that memory lives inside someone else’s product, in a shape I can’t open in a text editor.

Two convictions came out of the planning months.

The first: the brain has to be mine. Plain markdown, version controlled, on my own disk. I’ll happily rent the capabilities (the agent framework, the models, the skills) but the system of record never goes anywhere I can’t export from. There’s a line from the planning notes I keep coming back to: you can’t trust a memory you can’t read.

The second: one assistant isn’t the shape I want. I want a staff. The persona that hoards context about everything I’ve ever shared shouldn’t be the same one holding shell access to the machine. Splitting them isn’t theater. Each persona gets its own memory, its own model, its own permission boundaries, and its own way of failing, which makes each one auditable in a way one giant do-everything agent never is.

the shape/

The stack, in one paragraph. An always-on agent framework called Hermes hosts the personas, each one a profile with its own config, memory, and Discord bot token. Claude Code runs alongside as @dev on a flat-rate subscription and does the heavy building, while the personas orchestrate over short API calls. Personas decide, dev produces, and that sentence is also the cost model. Discord is the doorbell: I message a persona from anywhere and it reaches a machine with no public ports at all, because the bots dial outward and admin access runs over a Tailscale mesh and nothing else.

A surprising amount of the plan is about what not to build. Hermes ships a large skill library, so most of the work is curating and configuring rather than authoring; the list of things I’ll write myself is five items long. No custom dashboard; the built-in one is fine until it isn’t. No model router either, deferred until bulk routing or failover became a real need. Claude Desktop stays off the Mini too, because a GUI app on a headless box is the piece that fits worst. The operating principle sits at the top of the master plan: minimal core, pull-based periphery. The idea pool is a menu, not a recipe.

what it isn’t/

It isn’t a smart home and it isn’t Jarvis, despite the name of the folder all this planning lives in. There’s a phase 2 on paper (a bigger hardware mesh with an AGX Orin at its center) that’s parked, unmaintained, and not allowed to leak into phase 1. The products I eventually want to build with this setup are separate projects entirely; the command center exists so that building them gets easier. It’s infrastructure, and I’m trying to keep it boring the way infrastructure should be.

I should also be precise about the division of labor, since “I’m building an AI command center with AI” invites an obvious question. The AI side has been very good at checklists, defaults, and research legwork. The calls have been mine: the architecture, the sequencing, what got rejected, and the occasional bug the machine couldn’t see. I wrote about that split once already, back when it was one person and one model building a browser extension. It changes shape when there are four of them with different permissions, and that gets its own post.

where it stands/

The foundation came first and got proven early: hardened macOS, Tailscale-only access, key-only SSH, and the power-cord test up top. The accounts layer was quietly the more interesting work: a dedicated identity for the machine, separate from every personal account I own. A GitHub org configured like a threat model, because its newest member is an autonomous agent. A Discord server where four bot accounts sat with custom avatars and nothing behind them yet.

That was the honest state in the first week of July, when I drafted this: the team had names and faces and no lungs.

It happened in the planned order after that. Claude Code on the Mini, then Hermes, then @kAI answering on Discord. The team that actually runs today is leaner than the org chart above, and a later post covers what got folded and why.

One thing on the not-building list has already been settled for me. The router I deferred until failover was a real need: the need arrived a few weeks later, and it turned out Hermes had shipped failover the whole time. That’s happened often enough now that I’ve stopped calling it luck. Everything else in this series comes from operating the thing rather than planning it.