Skip to content
← Back to writing

December 11, 2025

I built an AI assistant that actually works (not a chatbot)

Not a chatbot. An operator. Running in the background, handling operational work, surfacing only when it needs human judgment.

What I actually wanted

The real specialist-agent roster from the repo's .claude directory: sixteen role-scoped agents — docker, networking, security and auth, the media stack, monitoring, backups, testing, debugging, deploys, docs, project management, review — plus the /autoroute task-to-agent routing table.

I did not want a better chat window. I wanted something that keeps working when I close the laptop.

A chat assistant waits for you. You type, it answers, the conversation ends, and tomorrow it has forgotten all of it. That is fine for a lookup and useless for running things. What I needed was closer to a coworker: something with tasks of its own, a schedule, a sense of what happened last week, and the judgment to stop and ask before it does anything I would regret.

So that is what I have been building: a custom agent framework on top of Claude that handles the operational work around my products while I sleep. One person, several products, never enough hours, and the framework is the only way that math works.

How it started

Early in 2025 I was using Claude the normal way: ask a question, get code, paste it into HomelabARR, debug when it breaks. It worked well enough, except every session started from nothing.

The problem was always context. New conversation, blank slate. I would re-explain my stack, my conventions, my infrastructure every single time, and it still had no idea what I had changed the day before, so every session played like a first day on the job.

So I started building the memory it was missing. First a system prompt with project context, then reference files it reads at the start of each session, then separate agents for separate kinds of work, then persistent notes so it could carry something forward. Somewhere in there the thing I was building stopped being a tool I reached for and turned into a teammate.

The auto-router

The first part that genuinely changed how I worked was the router. Instead of one generalist trying to be good at everything, I split the work across specialist agents and put a router in front of them: Docker, networking, security and auth, the media stack, monitoring, backups, testing, debugging, deploys, docs, project management, review. You describe a task and the router decides who should own it.

The point was chaining. Adding a new service to the homelab is several jobs in sequence: the Docker agent standing up the container, then networking wiring the Traefik route, then security setting up auth, then testing checking that the whole thing actually answers. The router sequences that so I do not have to hold the order in my head.

I built this before "agentic workflow" was a conference track. Not because I was early on purpose, but because a homelab with thirty-odd services genuinely needs different expertise for different problems, and one model pretending to be all of them kept getting the details wrong.

Making it proactive

The router still waited for me. It was a very good assistant that did nothing until asked, so the next step was getting it to act without me starting the conversation.

That meant scheduled work. A morning pass over calendar and email. An evening read of the day's commits to flag anything that looks half-finished. An overnight look at the firewall logs. None of it is clever on its own, just small jobs on a schedule, but each one is a thing I no longer have to remember to do.

Then the memory got real. Session notes for what happened, reference docs for what matters past this week, and patterns: rules it picked up from getting something wrong and not wanting to repeat it.

What it does so far

Right now it can send me a morning briefing with calendar, an email summary, and where each project stands. It watches my repos for stale branches, red CI, and uncommitted work. It hands implementation tasks off to Claude through my own scripts. It runs a nightly look over firewall and network activity. At the end of the day it commits and pushes anything I left hanging, and it pings me the moment something needs a human to decide.

The more important list is what it does not do. It does not send email without my sign-off. It does not spend money. It does not deploy to production on its own. It takes the overhead around the edges and leaves the decisions to me.

The patterns it writes for itself

The part I am most pleased with is the one I did not write by hand. When it gets something wrong, sends a badly formatted message, misreads a request, breaks something mid-deploy, it writes itself a rule: a trigger, an action, a reason. If that rule stops the same mistake next time, it stays. If it fires when it should not have, I correct it.

A few of these are already load-bearing. Show a draft before sending anything external. Never touch system config without asking first. When a task involves money, stop and confirm. I did not sit down and program those; they are scars, and they made the thing more careful than my instructions alone would have.

There is a real difference between an AI you configure and one that accumulates judgment. Configuration only covers the cases you thought of in advance, while the patterns cover the ones I hit in practice and never want to hit twice.

What building it taught me

Context decides everything. A model that knows your codebase, your infrastructure, your habits, and your recent history gives answers you can use. The same model with none of that gives you a competent stranger's guess.

Memory has to be deliberate. Dumping old chats into a vector store gives you a junk drawer you can search, which is not the same as memory. What works is curated and layered: session notes for what happened, reference docs for what lasts, patterns for what to do about it.

The boundaries matter more than the capabilities. What keeps me up is what it will refuse to do without checking. Something that emails on your behalf uninvited is a liability, and the trust I put in it comes from the times it says no.

And the operator shape is the one I keep coming back to: something that runs in the background, does the operational work, and surfaces when it actually needs me.

What's next

I want to package this so I am not the only one who has it: the identity files, the memory layout, the patterns, the agent roles, the scheduled jobs, as a kit you can scaffold your own operator from instead of rebuilding it by hand. The operational habits that make an operator worth keeping around day to day are the part I am still figuring out.

mjashley.com