In Twin Peaks, FBI Special Agent Dale Cooper investigates a murder in a strange town with a handheld tape recorder and an assistant named Diane. You never see Diane. Cooper just raises the recorder mid-stride, says "Diane," and starts talking: observations, hunches, the weather, the trees, what he ate for breakfast. He dictates the thought as it happens, from wherever he is, and trusts it lands with someone who will hold the context.
It dawned on me as I started using Wispr Flow to talk to my upgraded chief of staff (Kubrick 3000) in Slack that maybe I'm trying to build the 2026 version of this tape recorder. Twin Peaks: the tape recorder captures the thought and remembers the context. 2026: the tape recorder talks back.
That's more or less why I'm building all of this.
I've been building an AI chief of staff in public for the past few months. The public repo is founder-cos; I call my personal version of it Kubrick 3000, and its brain (my second brain) lives in a private GitHub repo full of markdown files. (Also 2026: it's AI). The future is weird.
From the first week building this, I wanted to talk to my chief of staff anywhere, especially on my phone. Especially with my mouth. Kind of like Diane.
But I also wanted this to be an accessible chief of staff, something far safer, cheaper, quicker, and easier to use than OpenClaw or Hermes. I wanted anyone who was scared of the command line to create a Cowork folder from the above founder-cos repo, just start, and be off to the races in an hour.
So I've been chasing a real mobile interaction for months but in various GUI sandboxes. I ran a parallel branch of the brain on Codex. I tried Anthropic's Dispatch on my phone. I tried a unidirectional Slack channel and then added the Claude app to it. Each attempt got a piece of it, but none got me fully off the laptop and all of them left me cold.
Since I launched this series, from my first announcement, sat the destination: my own VPS enabling a chief of staff I can reach from anywhere because it runs in a cloud server I control.
But the catch was that that move would also break the original accessibility vision. No matter how much I want this to be usable by someone who doesn't know what the command line is, what GitHub is, or what DigitalOcean is, v3 is not that version.
So here we are: v3 fails the accessibility test, but it sure does pass the user experience test.
Why Slack
Slack is boring. It's bland. I'm there throughout the day anyway and it's an easy surface that's not super distracting like Telegram, Whatsapp or Discord.
One of the things I've loved about Slack since launched is its ability to beautifully blur the line between desktop and mobile. You really feel parity between both versions and I find myself easily slipping between them. Also, for whatever reason, Slack is one of the few apps I actually enjoy getting notifications from.
An assistant you visit in an app feels like a tool. A chief of staff that sits in the room where your work is already happening feels helpful. It's less overhead, less like a destination and more like a colleague you can turn around and talk to.
This is especially true for the way I actually use Kubrick 3000. I don't need a giant chat surface most of the time. I just need to answer a few Socratic questions Kubrick's morning brief asks me. I need to capture a state change before the next agent reads stale files. I need to say, "1 signed, 2 sent, 3 still waiting," and have the brain understand that those are answers to numbered ASKs from the brief.
Tiny inputs, durable memory. That's the idea.
You know, Diane.
There's also the phone. If I can dictate into Slack with Wispr Flow while walking to get coffee and the brain updates itself, something amazing happens. It stops being software I operate and becomes something organic and connected to the flow of life away from a desktop. A tape recorder at worst. A real-time to do list. A smart, friendly, interactive notebook. A real chief of staff at best.
The build
Last night I was adding todos into Kubrick 3000 from bed so I could get them out of my head before I forgot them. No Mac mini, no MacBook, just an always-on VPS in the cloud. Knowing that they were captured, remembered and would automatically resurface when needed meant I could rest easy. That felt new.
The stack isn't glamorous:
- Node 22 + TypeScript
- Bolt Socket Mode for Slack
- Claude Agent SDK
- A clone of the brain repo on the Ubuntu VPS
- Systemd for the worker
- A serialized git writer so the model never runs git itself
- A budget ledger for runaway protection
- Slack threads mapped to resumable agent sessions (NLG this part makes it feel pretty seamless)
The worker answers every message from me in #kubrick. No mention ritual. No "hey Claude" incantation. If a message starts with ., Kubrick ignores it. Otherwise it assumes I mean to talk to my chief of staff.
The re-tagging ritual was the crack in previous versions (I had tried the Claude bot, I tried making a kubrick bot without the VPS). It turned the channel into another place where I had to remember the syntax of the system and it didn't feel natural. Also, there was no persistence of memory and conversation. A good chief of staff shouldn't require a summoning ceremony every time I need to think out loud.
The new model can read, grep, glob, edit, and write files in the brain clone. It can't run Bash. It can't run git. It can't wander around the VPS. At least yet. The worker owns the git path: pull, rebase, commit, push, retry.
The brain is the source of truth. If Kubrick says it captured something, it has to be on disk. If the file didn't change, the system didn't learn. That was one of the hard-won v2 lessons: the brain is a runtime log, not an end-of-day archive.
Economies of micro scale
With AI models and business models changing weekly, the make-or-break constraint for all this working for me was billing.
I already pay $100/mo for Claude Max. I wasn't excited about building a personal chief of staff that used my subscription for interactive work and then charged me separate API credits for the same model on my own server.
The key finding was that claude setup-token creates a long-lived OAuth token for CI pipelines and scripts. The Agent SDK wraps the Claude Code CLI, which honors that credential chain.
In other words, the worker just uses my existing Max plan. Great.
The day-two numbers:
- Decision to verified worker: about one day
- First brain-grounded phone-to-Slack answer: 17 seconds
- Ack reaction: under 2 seconds
- RAM idle / turn peak: 53MB / 211MB
- Marginal inference cost: $0 on the existing Max plan
- Marginal infra cost: $0 on the existing VPS
- Tests: 30 green
- First autonomous brain commit:
e1bb01e, authored by "Kubrick 3000"
The number I care about most isn't the $0, though that helps. It's 17 seconds.
That's short enough that I don't get impatient and leave the conversation. It's short enough that the system feels present, persistent, and not batch-processed without context.
What didn't move yet
v3 isn't "everything now runs on my VPS."
The interactive worker runs on the VPS. The inbound conversation, capture loop, Slack replies, thread continuity, git writer, and failure reporting live there now.
The four scheduled heartbeats still run as Anthropic cloud Routines today: the morning brief, the weekly goal-set, the weekly recap, the monthly consolidation.
Pointing to future versions, the repo already has a dormant replacement for them: a heartbeat runner, systemd timers, the same prompt files, the same writer discipline. But it's not enabled yet.
So the boundary is that v3 owns the interactive Slack modality first. Heartbeats will migrate later, one at a time, when the connector story is actually solved. Maybe that means GitHub Actions when I'm ready to try this in other models too. We'll see.
What it feels like
My early take so far is that Slack feels a lot more fun for these conversations. Claude felt sluggish, Codex felt too technical, but my #kubrick channel has just the right amount of casual conversation to make me want to go back there on my phone or my laptop.
When Kubrick asks an open question in the morning brief and I can answer in the thread, from my phone, the loop feels short. I used to just get these flat posts to the channel. Being able to interact with them now feels like magic. When the system is always one Slack message away, capture has a chance to happen at the moment of thought instead of 15 minutes later when I've forgotten it.
Part of Kubrick 3000 is just supposed to be a friend or colleague that won't let you forget anything.
Today I did my morning brief in the kitchen, talking to my phone in between doing dishes. This usually happens after my son leaves for school. Today it happened before he woke up.
The first note I sent a friend about v3 wasn't about the architecture. It was about the experience: fast and fun, on my phone, a nice little power up. Cooper and Diane, except she answers back from the tape recorder. Crazy.
The series thesis
The funny thing about building a personal chief of staff is that the frontier model is only half the problem.
Everyone wants to talk about this week's model. But the more I build this, the more the durable parts look like:
- the second brain
- the operating rules
- the write discipline
- the Socratic question discipline
- the privacy
- the interface where I actually want to show up
The brain is markdown. The repo is git. The routines are prompts. The worker is TypeScript. The surface is Slack. The engine is Claude Fable today, back to Opus tomorrow and could even be an open model later.
The stack will inevitably change. I won't.
I want my chief of staff to live in my work, with my memory, on infrastructure that is solid, but interchangeable.
That's what Kubrick 3000 is. Not a Slack bot. My chief of staff with a private channel in Slack.
Play with v3: https://github.com/tarikh/founder-cos/blob/main/v3-slack-vps.md
Make your own Slackbot: https://github.com/tarikh/cos-slack-worker