I built an AI that runs my life. It has 13 employees.
A full walkthrough of KeepOS: how my AI agent runs, remembers, delegates and acts on its own, built on Claude Code, Obsidian and one run queue.
KeepOS is the system I'm building to run my work and my life. Its lead agent is Rook. Rook lives on a Linux server in my homelab, reads a vault of my notes, does work from it and writes back to it. I reach it from my phone. It also reaches me first.
This system never stops being built, so the numbers in this post are live: Rook counts itself every morning, and they were last counted on November 18, 2026. Today it's Rook and thirteen specialists. The diagrams and phone screenshots are from November 5, three days after the first commit. The org chart is from November 18. The plan is hundreds of agents, with far more tools, and this post will change as they ship.
This post goes through how the whole thing works. How a run executes. How memory holds up across conversations. How thirteen specialists fit under one agent. How it acts without being asked, and where the model is not allowed to decide.
Want that brain on your own notes? The graph is open source, and so is the core of the whole system. Get KeepOS on GitHub and run the graph on any Obsidian vault.
The system at a glance
There are six moving parts.
- The vault. An Obsidian vault of plain markdown in a git repo. This is the source of truth.
- The runtime. Claude Code, running headless. Every piece of agent work is one run of the CLI.
- The service. A small Node and TypeScript process that receives messages, schedules work and spawns runs.
- The specialists. Thirteen named subagents, defined as markdown files in the vault.
- The tools. Nine small MCP servers I wrote, for calendar, mail, school, jobs, content, investing and more.
- The app. A dashboard that installs on my phone like a mobile app. I can chat with any agent or call it and talk out loud, watch runs live, read the vault, and approve posts and emails from anywhere. Telegram and the app share one conversation, so what I say in one shows up in the other.
The service holds almost no intelligence. It's plumbing. All the reasoning happens inside a run, and everything worth keeping ends up in the vault.



Anatomy of a run
Say I send Rook a message on Telegram. The bot checks that it came from me, and nobody else gets an answer. Then this happens:
- It joins the queue. It goes in its conversation's lane and waits for a free slot.
- The vault syncs. The lane gets its own copy of the vault, up to date. A failed pull never blocks the reply.
- The prompt gets built. Identity files go in the system prompt. Fresh context goes in front of my message.
- The CLI spawns. The service starts Claude Code inside the vault directory.
- Progress streams back. Every tool call becomes a plain status line in the chat.
- The vault pushes. Whatever changed gets committed, merged back and pushed.
- The reply lands. Telegram gets the final text, and the exchange goes in the daily log.
A sample run: a question goes in, the service queues it, pulls the vault, starts Claude Code and hands off to a specialist, then commits the result.
The spawn is the center of the system. Stripped down, it looks like this:
claude -p \
--output-format stream-json \
--append-system-prompt-file <identity> \
--mcp-config <tool servers> \
--agents <specialists> \
--resume <session>
stream-json matters more than it looks. It's how the service sees each tool call as it happens, which drives the live status lines. It also carries the subscription's rate limit events, so the system knows when it's out of usage instead of failing silently.
How runs share the vault
Every run reads the vault, writes the vault and touches git. Two at once in the same folder could corrupt either. So for the first ten days the queue was a single promise chain, about ten lines long, and every run waited for the one before it.
That was the simplest design that couldn't produce a race. It also meant a slow job held up my messages. So the queue now runs in lanes.
- A lane is one thread of work. A conversation is a lane, and so is each job. Inside a lane, runs stay in order, because a Claude Code session can't take two turns at once.
- Lanes run side by side. Two at a time today. Each lane works in its own git worktree of the vault, so no two runs ever write the same folder.
- Git does the merging. When a run ends, its changes merge back into the vault and get pushed. If two runs edited the same lines, the loser is parked on its own branch for me to look at. Nothing gets forced.
- Some work still runs alone. Changes to Rook's own code, the wrap-up sweeps, jobs that reorganize the whole vault, and job applications, which share one browser.
How memory works
A chat window is a bad place to keep a life. So memory comes in four layers, each with a different lifespan.
Layer one: identity
Three files define the core: who Rook is, how it behaves and who I am. They load fresh from the vault on every run. If I edit one in Obsidian, the next message uses it. A long conversation can't bury them.
There's a cost trick here. The system prompt stays byte-identical between runs, so the prompt cache keeps working across a resumed conversation. Anything that changes, like the current time, goes in front of the user's message instead.
Layer two: the session
A conversation is a resumable Claude Code session. It stays alive while we're talking and retires after a stretch of silence, or when I type /new.
Retiring a session triggers one last run with nobody on the other end. Its only job is to file anything durable into the vault. That wrap-up turn is why a chat can reset without losing what was said.
Layer three: recent context
A fresh session shouldn't start cold. So it gets the last few daily notes, the notes changed in the past 48 hours and a digest of recent conversations.
The prompt tells Rook to hold that the way a friend remembers yesterday, as continuity and not as an agenda. Without that line, it reads your own week back to you like a case file.
Layer four: the vault
Everything long-term lives here. People, projects, decisions, daily notes. Every conversation also gets logged to a dated note, words only, with no tool noise.
Two notes keep it from going stale. Now.md says where things stand this week, and a job rewrites it every Sunday from the week's notes and conversations, moving lasting facts into the notes they belong in. Meta/Index.md is one line per note, rebuilt by code, and it flags notes that claim to be current but haven't changed in a while.
Because the vault is plain files in git, I can read every memory, correct any of them and see the history of each change. If I edit on my laptop while Rook is writing, the push rebases and retries.
The model is replaceable. The vault is not.
Why there's no vector store
Rook finds things the way a developer does. It searches files, follows links and reads what it finds. There are no embeddings and no chunking.
Plain search has one weak spot: a word that shows up in fifty chat logs buries the one note that holds the fact. So Rook has a recall tool that ranks results. Notes beat chat history, a match in the title or frontmatter beats one in the body, and newer dated material comes first. Each hit comes back with a snippet, and Rook opens the file that looks right.
I chose this because it's inspectable. When recall goes wrong, I can see exactly which files it read. A note also keeps its full context, because nothing gets cut into pieces.
I haven't benchmarked this against a vector store. So the system collects the evidence instead. Every search that finds nothing gets logged to a note, and so does anything Rook should have known but found only the hard way. If real misses pile up there, search needs meaning-based recall. If that log stays quiet, it doesn't. At 464 notes, it's quiet so far.
The specialists
One agent with every tool gets vague. So Rook delegates.

- Kairo handles school: deadlines, grades and what needs doing this week.
- Argus tracks my investments and researches them. Iris finds out why a stock moved.
- Herald runs my content. Maker builds each post, Scout researches the web, Analyst reads the numbers and Critic judges every post before I see it.
- Hunter runs the job search. Courier fills in the applications I approve.
- Milo handles food, training and health.
- Cadence runs outbound email for Elenos. Scraper builds its lead lists.
A specialist is a folder in the vault with two files. One defines it: a description, a model, an optional tool list, a parent and a personality. The other is its memory.
Adding an agent takes no code. The service reads every definition fresh on each run and hands them to the CLI. The description is what Rook reads when it decides who gets the work, so that line does the routing.
A few details carry weight:
- Memory goes in the prompt. Up to 16,000 characters of an agent's memory file gets injected at the start. The agent rewrites that file before it finishes. Nobody keeps it for them.
- Teams nest. The
parentfield puts an agent on a lead's team. Rook hands investing work to Argus, and Argus hands the news question to Iris. - Each agent gets its own tools. Scout has web search and web fetch, and nothing else.
- I can talk to them directly. That opens a separate session, so a thread with one specialist never bleeds into the thread with Rook.
How it acts without being asked
A chatbot waits. This system has five ways to start on its own.
- Scheduled jobs. A job is a markdown file with a cron schedule and a prompt. Seventeen are on, including a morning brief, a daily note and nightly vault cleanup. Ten of them run on Haiku to save usage.
- Event triggers. A poller checks my calendar and inbox every five minutes. Rook briefs me before a meeting and asks how it went after. New mail goes through a cheap triage run, with quiet hours overnight.
- Self-scheduled follow-ups. Rook can set its own reminders. They run through our conversation, so when I reply it knows what it asked.
- The market watcher. Plain code polls prices, SEC filings and headlines all day. Argus only wakes when something trips, and it's capped at four runs a day. Hunter works the same way: plain code watches for companies that just started hiring, and he only wakes for a fresh one that fits.
- My phone. iPhone automations wake Rook when I turn off my alarm, start the car or get home, and it talks me through what matters. When something can't wait, it calls me.
One pattern runs through all of them: polling is plain code, and the model only runs when something fires. Checking an inbox every five minutes costs nothing. Paying a model to do it would burn the whole budget.
The other hard part is silence. Most runs should send nothing, so a job can end with a marker that means stay quiet. A proactive agent lives or dies on restraint. One useless ping and you start ignoring all of them.
So the system also tracks which messages I ignore. The check-in that runs every few hours and the weekly self-review both read that record, and learn to send less of what I ignore.
Usage limits get the same care. If the subscription runs out mid-job, the job waits for the reset and retries instead of disappearing until tomorrow.
Where the model doesn't get the final say
Rook has shell access on its own server, and it reads email and the web. Any text from outside could be an attack. Prompt injection is a design input here, not an edge case.
So the question for every action is who holds the last word.
- Publishing. An approval stores a SHA-256 hash of the caption and every asset. A post only goes out while that hash still matches, so nothing can change after I sign off. The publisher is plain code, and the agents have no approve or publish tool.
- Posting on silence. Some posts can go out without a tap, and code decides which. It has to be finished, with no open claim checks, no outside links and no news or client topics. I'm told a day ahead, never less than six hours, and it goes out unless I kill it. Anything that makes a claim about someone else always waits for me.
- Applications. Nothing gets submitted until I approve it from Telegram or the app. That approval is written somewhere the agent can read but a web page can't reach. When a job portal needs an account, the password is filled in by code, and the model never sees it.
- Money. The brokerage connection is read-only. Trading is off at the connection itself.
- Email. Rook can read and draft, but it can't send anything itself. An email goes out only after I tap Send in Telegram or the app, and that approval lives outside the model. Hunter's cold emails to recruiters also have limits checked in code: a short length, one email per person, a few people per company, a daily cap and a single follow-up.
- Headlines. Market events reach the prompt as checked tickers, numbers and fixed topic names. A raw headline never does, because anyone can write one.
- Web reading. Iris and Scout read the open web with no vault, no shell and no memory. A malicious page has nothing to steal.
- The dashboard. It lives on my private network, behind a PIN with lockouts. The terminal that edits Rook's own code sits behind a second PIN.
Publishing approval is tied to a hash of the exact post, so any change voids it.
The real check hashes the caption and every asset. This demo hashes the caption, and it runs in your browser.
It's the same rule I used on my Instagram bot. If a mistake would be expensive, the model doesn't decide. Code does, or I do.
This lowers the risk. It doesn't remove it. An agent with a shell that reads the internet will always carry some.
What stays on my hardware
It's worth being exact, because "local" gets used loosely.
The server, the service, the vault, the tool servers, the voice transcription and the voices on calls all run on my own hardware. The model does not. Rook runs on Claude, hosted by Anthropic, so whatever a run reads goes to Anthropic to be processed. That's the prompt and the files it touches, not the whole vault at once.
It didn't start that way. I originally ran a local model through Ollama. Claude Code performed better, so I switched.
I made that trade knowing what it costs. A local model keeps every prompt on my own hardware. A hosted one does the work better today. For an agent I depend on daily, performance won.
It isn't permanent. Once I have hardware that can run a strong enough model, I'll explore Ollama again.
It edits itself
Rook can change its own code from Telegram. It works in a separate git worktree, so a half-finished change never touches the live service.
I can also do it from a terminal in the app. I watch every tool call live, read the diff and tap ship or discard.
Shipping has gates. The change has to pass a typecheck. Anything touching packages, secrets or runtime data gets refused. Then the service restarts, and if the bot doesn't come back within a minute, it rolls itself back.
Those gates exist because of a real failure. An early ship committed node_modules, which in the worktree was a link to the live install. Shipping replaced the real packages with a dangling link.
Rook also reviews itself. Every Saturday it reads its own week and looks for where it got corrected, missed something or made noise. It proposes rule changes, and it can't apply them until I approve.
What broke along the way
The self-edit failure was the worst one. Two smaller ones taught me more about agents.
Stale news. Rook filled my home screen from web search, and the pages came back old. The morning brief also kept skipping the task, because it was one chore inside a long job. News got its own job, reading dated RSS feeds. A date you can check beats a search result you have to trust.
The silence marker. My code looked for an exact match on the quiet marker. Models like to explain themselves first, so the reasoning landed on my phone followed by the marker. Now the check finds it on its own line or at the end of the message. Never assume a model will output only the thing you asked for.
From a handful of agents to hundreds
This system is meant to keep growing. The repo took 141 commits in its first four days and is at 284 now. I plan to take the roster from thirteen specialists to hundreds, with far more tools.
Each new tool makes every agent more useful. Each new agent gives the vault more to remember. A note becomes a memory becomes a decision the next run doesn't have to make twice.
Defining an agent is already one file. Running hundreds is a different problem. Three things have to change:
- The queue. Lanes let runs share the vault without colliding, but two at a time won't hold for hundreds of agents. More lanes means more merges, and more chances two agents edit the same note.
- The budget. Rook shares my Claude subscription with my own work. Every agent draws from the same limit.
- The routing. Rook picks an agent by reading descriptions. That gets harder as the list grows, which makes the nested teams more important.
Those are the next problems. I'll write them up as they break.
Spec sheet
| Agent runtime | Claude Code, headless |
| Model | Claude, hosted by Anthropic |
| Memory | Obsidian vault in a private git repo |
| Service | Node and TypeScript on a homelab Linux server |
| Channels | Telegram, voice notes, live calls, Siri and iPhone automations, an installable mobile app with push notifications |
| Runs at once | Two lanes, each in its own copy of the vault |
| Agents | Rook plus thirteen specialists |
| Scheduled jobs | 17 active |
| Own tool servers | 9 |
| Tests | 188 |
| Code | 29,908 lines |
| Open-source core | KeepOS on GitHub |
| Model cost | My existing Claude subscription, no per-token bill |
| First commit | November 2, 2026 |
What it doesn't do yet
- Run many things at once. Two lanes at a time, and anything that uses the shared browser still runs alone.
- Prove its memory. There's no benchmark against a vector store, only a log of the searches that came up short.
- Rule out prompt injection. The boundaries lower the risk and nothing more.
- Ship everything in the open. The core is open source as KeepOS, and you can run it yourself. The integrations wired to my own accounts aren't public.
Changelog
November 18, 2026. Runs now go in parallel lanes, each in its own copy of the vault. Five new specialists: Critic, Courier, Milo, Cadence and Scraper. Ranked recall, a weekly memory distill and a log of search misses. Posts that pass every check can go out unless I kill them. Live calls, phone automations, and a record of which messages I ignore.
November 11, 2026. Open-sourced the core as KeepOS. The numbers in this post are now live, counted by Rook every morning.
November 6, 2026. First published. Rook plus eight specialists, 14 jobs.
I'll update this list as the system grows. If you want to see what I build for businesses, start here.