the operating system I built for myself
A case study in agentic AI: a personal operating system that reads, sorts, drafts, and remembers across email, files, and notes, with me approving anything that leaves the building.
At a glance
Role: Architect, builder, and sole user
Reasoning layer: Claude (Anthropic), organized into scoped project workspaces
Connected systems: Google Workspace, Obsidian knowledge base, GitHub, iCloud, Squarespace, Canva
Core patterns: A nine-agent team with a QA gate, persistent memory, reusable skills, scheduled runs, approval-gated actions
Status: In daily use
The problem: attention debt
Most people think their problem is too many tools. Mine was too many inputs. Three Google accounts, an old Yahoo Mail account, and iCloud, with more email than any one person should read, files spread across drives, and notes in apps that never talked to each other. Every input asked for a small decision: keep, file, answer, ignore. Individually, nothing. Together, a tax on every working hour.
My brain doesn’t work the way most productivity advice assumes. Systems that depend on me remembering, sorting, and following up by hand don’t last. I didn’t need a better to-do app. I needed something that could carry part of the load.
It’s also the problem I watched for 12 years running a fly shop and guide service, and still see across the outdoor industry. In most small businesses, the owner is the integration layer. Every system connects through one person’s inbox and memory, and when that person is on the water, everything waits.
The design brief
Before building anything, I wrote down what the system had to do and what it was never allowed to do.
Reduce decisions, not just steps. Saving clicks is nice. Removing the need to decide is the real win.
Keep a human on every irreversible action. Read, sort, and draft freely. Send, publish, or delete only with my approval.
Carry context between sessions. I shouldn’t have to re-explain who someone is or what we decided last week.
Work on the bad days. A system that only works when I’m sharp isn’t a system.
Stay replaceable. Any piece should be swappable without rebuilding the rest.
Architecture
The system runs in five layers. Each has one job, which makes it easier to trust and easier to fix. The nine agents described below work inside these layers: they do the reasoning, share the memory and skills, and all stop at the same approval gate.
Sources. Google Workspace, an Obsidian vault, GitHub, iCloud, and Squarespace, connected through standard connectors (MCP) so the assistant works from live data instead of copy and paste.
Reasoning. Claude reads, summarizes, sorts, and drafts. Work is split into separate project workspaces by domain (this website, new ventures, career), so each conversation starts with the right context and nothing else.
Memory. A curated, persistent memory holds stated facts and decisions: who people are, what’s in flight, how I like things done. It’s organized by subject and edited deliberately.
Skills and schedules. Repeatable procedures are packaged as skills, and recurring jobs run on a schedule: a morning brief at 6:37 every day covering email, calendar, and my project roadmap, a handoff runner that moves work between agents three times a day, a daily ingest that files new notes into the knowledge base, and a weekly health check that audits it for broken links and contradictions. The work happens whether or not I remember to start it.
The approval gate. Every action is sorted by how reversible it is. Reading and drafting pass through. Sending, posting, purchasing, and deleting stop and wait for me.
meet the ai agent team
Everyone below is an AI agent, not a person. The headshots are AI-generated too, so each role has a face.
One assistant doing everything hit a ceiling fast. Context bled between jobs, and nothing checked the work before it reached me. Now the work runs through nine agents, each with one job and its own instructions. They share a handbook and use only the tools their job calls for, and I approve everything that goes out.
-
Wes
Chief of Staff
Wes keeps the team running. He sets priorities, sends work to the right agent, and writes a morning brief so nothing slips. His other job is protecting my time.
-
Scout
Head of Research & Insights
Scout digs in before anyone builds or writes anything. She handles market research and fact-finding, and she says so when the data is thin.
-
Dex
Solutions Architect
Dex builds the tools behind the work, mostly scripts and automations that take repetitive tasks off the table. He starts with the simplest thing that works.
-
Ivy
Head of Marketing & Growth
Ivy figures out who needs to hear about the work and how to reach them. She plans the campaigns and the messaging, then pushes for one clear next move.
-
Nolan
Search & Visibility Strategist
Nolan makes sure the work gets found, both in search results and in AI-generated answers. He handles site structure and analytics, plus the technical details most people skip.
-
Vera
Head of Quality & Standards
Vera reviews everything before it reaches me for approval. She checks the facts and the voice, and sends back anything that misses, with a reason.
-
Reid
Managing Editor
Reid writes and edits in my voice, from LinkedIn posts to this site. He cuts hard and flags anything that sounds generic.
-
Jules
Creative Director
Jules sets the look. She owns the visual direction and keeps everything on brand.
-
Fisher
Senior Angling Advisor
Fisher knows the water, fresh and salt. He checks every fly fishing detail the team writes before it reaches an angler who knows better.
How work moves
A sync script Dex built runs every 10 minutes:
Shared folders from my knowledge base are mirrored out to a read-only share the agents work from. Private, health, finance, family, and career folders are never on the list.
Each agent drafts in its own workspace.
Finished work goes to Vera. Only what passes lands in an outbox.
The sync pulls each outbox back into the knowledge base’s inbox, where the daily ingest files it. A handoff runner moves work between agents three times a day and logs everything it moved, so I can see what happened while I was away.
None of the agents send, post, or delete anything, and they don’t write to the knowledge base. The one exception is Dex, who maintains his own scripts there, only with my approval.
Design decisions that mattered
Audit before automation. I inventoried every account, inbox, and storage location before connecting anything. Automating a mess just gets you a faster mess.
Scoped context beats one giant brain. It’s tempting to give an assistant everything. In practice, narrow context produces better answers and fewer confident mistakes. Separate workspaces keep website decisions from bleeding into unrelated work.
Memory is curated, not hoarded. The memory holds what I said and decided, not the assistant’s guesses about me, and sensitive details follow explicit rules about what gets stored.
Autonomy is earned. Each workflow starts in draft-only mode and gains independence only after it proves reliable. Anything that speaks in my name always waits for approval.
Secrets never touch the conversation. Passwords and API keys never get pasted into a prompt. When a workflow needs access to an account, it goes through a connector or a password manager that grants access without exposing the secret itself.
A normal morning
Before the coffee’s done, the morning brief has already been through the inbox. What needs me today sits at the top with a line on why. Receipts and newsletters are filed. A few replies are drafted in my voice, waiting for a yes or an edit. Anything new on a project lands in its notes, linked to what came before.
None of it is dramatic, and that’s the point. The best guide days feel the same way: the prep happened before the client showed up, so the day is about the fishing.
What I learned
Agents are fast at the first 80 percent and confident about the rest. The approval gate isn’t bureaucracy. It’s where quality control lives.
The prompt isn’t the product. The process is. Most of the value came from deciding what the system should and shouldn’t do before writing a single instruction.
What surprised me most was how much better it worked when I stopped scripting it. My instinct was to write strict instructions: do step one, then two, then three. Those do exactly what they say and nothing more. When I switched to describing the goal, the guardrails, and what good looks like, then let the AI write its own steps, the work moved faster and handled situations I hadn’t planned for. Good guides learn the same thing with new clients: give them the why and a few principles, not a twelve-step checklist, and they figure out the rest on the water.
Results
Email: an inbox of nearly 1,700 threads, most of them unread, cut to a few hundred that stay sorted. About 60 filters and dozens of unsubscribes keep it there, and the morning brief catches what slips through.
Files: about 30 GB consolidated from a second Google account into roughly 7,000 files across 10 subject areas, with about 145 stray iCloud files folded in. 78 key documents became searchable notes.
Notes: 1,103 scattered Apple Notes filed or archived into one knowledge base under 30 topic maps.
Yahoo: nearly 18,000 messages from an old account pulled into one place, sorted, and silenced, with 86 linked accounts identified and moving over.
Time: too early for an honest number. Building the system has cost hours. Running it already gives back the daily sort.
What’s next
The personal system was the proving ground. Next, I’m taking the same architecture further in public, with this site as the test bench.
The problem isn’t unique to my inbox. I’ve seen it in retail systems, in a fly shop, and on nonprofit boards: a few people end up as the integration layer for systems that don’t talk to each other, and it shows up as slow decisions and dropped follow-ups. The people should stay the decision-makers. The system should do the connecting.
That’s the thread I’m following, and this site is where I’ll share what I learn along the way.