Six weeks ago I gave Claude a folder of markdown files and a name for my new agent: Kubrick 1000.
The idea came from a friend's challenge. He'd hacked together his own chief of staff on a Mac mini and the command line. Could you build a no-code version in Cowork that runs off your own laptop? We weren't sure it would have the fidelity necessary, but it seemed like a worthwhile pursuit. There'd be a much larger audience for something that required less coding skill and worked with a graphical user interface. I was curious. I accepted the challenge and I was off doing research to see what could be borrowed from existing open source solutions like OpenClaw and Hermes.
I wanted a chief of staff, not a chatbot. Something that knows my goals at every resolution, captures context as I work, asks one sharp question when it spots a gap. I wanted an assistant that keeps me pointed at the highest-leverage task instead of the loudest one. NGL, I was a little dubious that the tools would be up to the task, but I posted about it, put up a repo for others, and friends started trying it for themselves and reporting back.
Six weeks in, here's the honest ledger of what's working, where it breaks, and what I want next.
The good
I use Kubrick every day. Morning, evening, and throughout the day. It's my go-to for what to work on and where to focus. There's something truly delightful about checking work off against a 90-day strategy and having an accountability partner who never forgets what you said you'd do. Helpful is the word I keep landing on, but some days it's truly delightful. I know it's just some algorithms and text files, but there's times I'm honestly proud to update it on a piece of progress.
I haven't written a line of code*. I could get faster results by rolling my own (and I will), but it's wild how far you can get without writing any code. A working chief of staff, assembled from markdown files and a bunch of instantiating conversations. That points at the future coming for everyone: the gap between can describe what you want and can have it is collapsing. *Worth mentioning there were some code-like moments setting up routines and scheduled tasks. There were also some genuine command line moments getting my second brain set up as a regularly updating, private GitHub repo.
The second brain is real. I now have a searchable archive of my thinking, my strategy, and my work. Every decision, every draft, every week's goals and whether I hit them. I can't believe I lived without it. (More honestly: I lived without it by using the Bullet Journal method and, uh, losing stuff.)
The plumbing got surprisingly far. Cloud routines and the Slack connector have gotten me pretty damn far without a Mac mini humming in a closet 24/7. The morning brief fires whether my laptop is awake or not. I think we cleared a real bar there.
So that's the good, and it's good. Given that this is a hack on top of Cowork that I'm running as a daily agentic chief of staff, there are some seams.
The occasionally forgetful temp with an occasional genius IQ
Picture this. You've hired the most dutiful chief of staff you've ever met. One catch: every morning is their first day.
They're sharp once they get going. But each day you re-brief them from scratch. They take notes furiously, narrate everything they do to prove they're doing it, and stuff every document they've ever touched into one overflowing notebook. By afternoon the notebook is so full they can't find the thing you told them at breakfast.
You wouldn't fire this person necessarily. But you would fix their onboarding. Here are my six big issues.
Dispatch is a task launcher, not a relationship. Dispatch should be a synchronous relay from your phone to your desktop session. In practice it's a place to fire tasks: send a request, get a result, done. But a Cowork project isn't a task. It's a long-running relationship, and the desktop already treats it that way with persistent per-project context. Mobile needs to inherit that, not reinvent it. Every fresh thread from my phone is the temp's first day all over again - in fact, in Dispatch, the temp isn't even sure what company (Project) it's working on.
It's slow. Cold starts, serial steps. The system re-instantiates and works one thing at a time when a colleague would resume mid-thought and delegate three things at once.
It's token-intensive. It re-sends the full context every turn. My brain files, the system setup, the whole world, paid for again and again. Re-briefing the temp every hour, billed by the word. Some mornings I burn through 10% of my max token usage just updating the briefing questions to get started. Ouch.
It's forgetful. Memory is session-scoped. Nothing durable survives unless I build it myself. (I did build it myself. Kubrick's whole brain is a stack of markdown files precisely because nothing native would hold.)
It's verbose. It seems tuned to show its work and cover itself. No register control. Ask for a number, get a memo. Colleagues don't narrate every step. New hires do, on day one. Every day is day one. There are some verbal tics too, phrases like "load-bearing" that I use myself maybe once a year appear multiple times a day. It even carries these tics into the drafts it writes for me.
Context pollutes. One flat window holds the task, the history, the tool output, and the scratch work. Signal decays as it fills. That's the overflowing notebook: the thing you said at breakfast is in there somewhere, under forty pages of intermediate work. I regularly have to ask it to resurface a markdown file that has gotten lost in the miasma.
Six issues. Two fixes.
I don't think this is six separate issues. I think it's two missing primitives.
Look at the first group: slow, token-intensive, polluted context, the fresh-thread problem. The system is built as a cold, flat task launcher. Every piece of work starts from zero, in one undifferentiated context window.
Fix the session model and all four could move at once. Make the session warm and persistent, so it resumes instead of relaunching. Split the stable context (the system, the brain) from the working delta, so you pay for what's new instead of the whole world every turn. Scope the contexts, so durable memory, task scratch, and tool output live in separate channels and the scratch gets garbage-collected. Let sub-agents fan out and return conclusions, not their entire transcripts. Make the phone a window into the same continuous session, mirrored live, the same way Claude Code works remotely.
The second group is forgetful and verbose. Those are missing contracts. A memory contract: structured, durable, written back across sessions automatically, so the agent's knowledge of you compounds instead of evaporating at midnight. I bolted this on with a filesystem brain, and it works, but the bolt-on is the proof of the need. And an output contract: answer first, detail opt-in, verbosity set by the user, default terse.
What I want next
So that's the feedback so far on this experiment. Here's the next tasks on my roadmap.
Dreaming. I want the brain to get smarter, not just bigger. Reflective passes that find patterns in its own memory. It would be incredibly cool to get some honest flavor of RL or recursive self-improvement. Concretely: I want Kubrick to stop making the same mistakes over and over. I would also like it to really learn from the edits I make to its drafts until it's got a much, much better model of my writing voice. A colleague who repeats an error twice gets coached. A colleague who repeats it twenty times gets replaced. Right now my fix is hand-written feedback files. I would like that loop to close itself.
Fully clouded. I want Kubrick running on its own thread, fully distinct from my laptop. Not a process I host. I want a colleague who's at work whether or not I am.
Talk to it like a person. Mobile, text, voice. Ask it questions walking down the street. Toss it a task or an idea and trust it's captured and will get resurfaced. The interface to a chief of staff should be the interface to a person: email, text, Slack, a call: you talk, they handle it.
Blazingly fast. Not faster. Blazing. The difference between a two-minute answer and a two-second answer is the difference between a tool you consult and a colleague you think with. I find myself multitasking more because I'm just waiting for Kubrick to chug through whatever token-busting process it's chewing on. I don't actually want to be multi-tasking this much, I'd like to be more focused, but I need a companion that can keep pace.
Smart about models and tokens. Right now I'm yoloing Fable 5 on everything and burning tokens like an enterprise company with a $500M monthly token budget. Most of what Kubrick does is routing, filing, formatting. A fraction of it needs frontier intelligence. I want the system (or me) to get smart about which model burns where. The 80/20 of tokens is sitting right there.
The whole ballgame
You could read the middle of this post as griping or performance tuning, but I think it's deeper than that.
The difference between a tool and a colleague is continuity. A tool starts fresh. A colleague accumulates. Every one of the six issues is a different perspective on the same gap, and every item on my wishlist is a different way of closing it. The relationship is the entire chief-of-staff thesis. It should be help that knows you. Help that compounds. Help that doesn't need re-briefing every morning.
And let me implicate myself: A lot of this is me holding a prototype to the standard of a finished colleague (and more advanced dedicated solutions). But that standard is coming, fast, and the teams that internalize relationship, not task as the primitive will get there first. Heck, Hermes launched a desktop app this weekend and I'm real curious.
The temp with the genius IQ doesn't need to get smarter. The models are already smart enough.
The temp just needs to mature past Day 0