In February I wrote that I had stopped chatting with AI and started delegating to it. I meant every word. I had an assistant I called LISA, running on a Mac mini at home and built on an agent framework.
Since then I have torn it down and rebuilt it more than once. Each version taught me something the previous one hid from me.
Why I started with a framework
At the start of the year, Claude Code was the tool I trusted most, and I couldn’t build on it the way I needed. It was brilliant inside a session. But I wanted it to run on a schedule, to remember what mattered across days and to reach the other systems I work in.
So I put a framework around it. First OpenClaw, then Hermes. Each one promised the missing pieces: memory, scheduling, channels, tools. And each one delivered them, more or less.
What I underestimated was the price of the glue. Every framework brought its own idea of what a job is, what a permission is, what a message is. I wasn’t building my assistant anymore. I was maintaining a translation layer between my assistant and the framework’s opinion of it.
The night shift nobody read
The moment that stung most was a quiet audit.
I went through the background jobs my assistant had been running for months. Research overnight, signals from my notes, ideas for side projects. On paper, it was exactly the “night shift” I had been proud of in February.
In practice, a lot of it was noise. One job had been returning stale results for months and nobody noticed. Another was a web search with a fancier name, producing reports nobody acted on. I had built a system that looked busy, and I had been treating busy as useful.
That one hurt, because it is exactly the mistake I warn teams about. Measuring activity instead of outcomes. I had just done it with an AI instead of a team.
What changed in the platform
Then Claude Code changed. It became open enough to build on directly. Hooks around every tool call. Permission rules per job, so a job can be told precisely what it may and may not touch. Headless runs on a schedule, with the model chosen per task. Connectors to outside systems that I could put my own checks in front of.
The framework was now the thing in the way.
So I rebuilt again, this time on Claude Code itself. Most of the scheduled work moved over, and some of it I simply switched off. Hermes still runs on the machine, but I barely use it, and switching it off is on my list. I’m telling you that because “fully migrated” is the kind of claim I would have made in February.
What it picked up today
On the Monday I wrote this, there were more than forty sessions open on the machine. Four were busy. Six more were done and waiting for me to look at the result.
One was working out whether it is cheaper to ship our clothing brand’s hoodies from one country or another. Two were building a traffic and SEO system for two websites, modelled on one it had built earlier for another site. Another was finding out how far an authentication integration on a client project had got, and what was still open. One was refreshing a presentation on AI that I have to give. Others were working through tickets, preparing meetings, rebuilding a friend’s website and looking into a newly published security vulnerability.
None of that started as a conversation. I wrote a sentence or two, picked a project and walked away.
Two opinions instead of one
The change I’m most pleased with is not technical. It’s a habit I gave the system.
Before it hands me a plan, an audit or a recommendation, it asks two different models for an independent opinion, with the same brief: Fable, a Claude model, and Astra, through OpenAI’s Codex. A different vendor on purpose. Where they agree, fine. Where they disagree on a fact, it has to go and check, and tell me which one was right.
The same two have to agree before the assistant learns a new rule from its own mistakes. Every night it looks at what went wrong, proposes a rule, and only keeps it if both reviewers approve. I can undo any of them the next morning.
It’s the same reason I want two people on a code review. Not because either is bad. Because they’re wrong in different places. And because it means I’m no longer the one who has to catch every mistake.
What I’d tell myself in February
Delegation was the right idea, and letting go is still the goal. I don’t want to spend my days checking, approving and deciding. That was the point from day one.
What I got wrong was where autonomy comes from. I thought it would come from a smarter model. It comes from everything around the model.
The weekly post on this blog gets written, checked, built, published and confirmed live without me touching it. Work I queue runs at night. When something breaks, a morning round tries to fix it and only wakes me if it can’t. When the two reviewers disagree on a fact, the system goes and checks instead of asking me. And a repeated mistake becomes a rule, so it shouldn’t land on my desk again.
There is still a short list of things that wait for me: changes in systems I share with other people, and messages to people in my name. In February that list wasn’t written down anywhere. Now it’s explicit, and I keep making it shorter.
I suspect I’ll rebuild it again. The next step I’m planning is small language models running locally, for the work that has no reason to leave the machine. The tools are moving faster than any architecture I can draw.
That’s what the checks are for. Not to keep me in the loop. To take me out of it, safely, one kind of decision at a time.