How I Built My Own AI Chief of Staff

A chief of staff, not a chatbot

The distinction matters more than it sounds like it should. A chatbot waits for you to open it, ask something, and read the answer. A chief of staff is already working when you're not looking — reading, flagging, filing, following up — and only surfaces what actually needs your judgment. I didn't want another tab to check. I wanted something that checked things for me and told me when I was needed.

That meant it had to live somewhere persistent — my own server, running continuously, with real access to my inbox, my files, my books — rather than a session that starts blank every time I open it. Persistence is what turns a language model into staff.

What it actually does, day to day

It reads my inbox and flags what needs me — not everything, just the handful of threads that actually require my judgment, while it handles or files the rest. It logs every receipt straight into my books the moment it lands, instead of that becoming a monthly scramble. It reconciles bank statements against invoices and tells me exactly what's missing, rather than me discovering a gap at tax time. It triages support questions for my SaaS product and only escalates the ones it genuinely can't answer. And it remembers — clients, projects, decisions I made months ago — so I never have to re-explain myself from scratch.

None of that is a demo running in a sandbox. It's running my actual business, today, in the gaps around a full-time job that has nothing to do with software.

A second, lighter build for my dad

Once the core version was solid, I built a second one — for my dad, handling his email and files. Same underlying architecture, scoped right down to what he actually needed. That's when I realised the pattern generalises: the hard part isn't rebuilding the engine each time, it's deciding what a given person's version should and shouldn't touch.

The hard part was never 'can AI answer a question'

Everyone selling AI agents right now demonstrates the easy part — the model answering a question well. That was never the bottleneck. The actual work is turning a language model into something that acts safely and consistently inside a real business: knowing when to just do the thing versus when to stop and ask first, remembering what matters without being told twice, and never quietly breaking something that already worked yesterday.

Those are the boring engineering problems nobody puts in a demo, because they don't demo well. But they're the entire difference between a toy and something you can actually run a business on.

What most 'AI agent' content skips

Most of what gets published about AI agents is prompts — a clever instruction, a screenshot of a good answer. Almost nobody shows the actual system underneath: the guardrails, the memory, the escalation rules, the months of correcting it until it stopped making the same mistake twice. That system is the product. The prompt is the least interesting part of it.

Taking a small number of businesses through the same build

I'm now taking a small number of businesses through the same process — a personal or business AI agent scoped to exactly what you need, whether that's inbox, files, bookkeeping, or support, running on infrastructure you actually own rather than a vendor's black box. If you're curious what that would look like for your own business, get in touch and I'll walk you through it.