Complexence OS: a voice-first agent method for staying oriented

I built this today. Not over a careful month. Today, on a day I had no bandwidth to build anything, out of plain need. All week I had been a little stunned at what happens when you stop asking an AI for one thing at a time and start chaining the steps, letting one hand off to the next. So tonight, running on empty, I breathed life into a setup I had been sketching, wired it into a Slack app I made last year and never finished, and watched it half stand up. It semi lives. It still has issues. But it is pointed the right way, and it is already a different way of working than I had this morning.

Here is what it does, on the day it was born. I open a note and talk into it, say whatever is in my head, and save. That is the whole obligation. Some hours later a single agent has read it, cleaned up my run-on speech, sorted each piece, written a short brief, and handed the messy parts to the right helper. I read five sections and clear the two that need me. When it works, the rest already happened.

I have been calling the thing underneath all of this Complexence, the capability of standing inside a system larger than yourself and still choosing. That essay was about the human quality. This is the machine I started building to run it, and I put the method online tonight, rough as it is, for anyone. I am calling it Complexence OS.

The name is older than the system

I have been circling this for a year. The name came first. I had a Marcus in my head well before any of the code, a right hand whose only job was to keep my own life legible to me. Last spring he took his first real shape as a Life OS dashboard, a wall of counts and tags and heatmaps that mirrored my days back at me. It was genuinely interesting, and it never once acted. It could show me the state of things and then just sit there, a beautiful read only mirror.

So I overcorrected and chased a cognitive twin, a model of me that could reflect and decide alongside me, recursive and ambitious and mostly theory. That detour was worth it because it taught me where the real edges were. Tonight all of it collapsed into something far humbler than any of the grand versions, and that humble one is the first that actually moved. The dashboard wanted to display. The twin wanted to think. What worked was talk, route, review. And the right hand I sketched a year ago finally has a name that sticks: the router is Marcus. I named him for Marcus Aurelius, who wrote his Meditations to no one but himself. That is close to what the daily note actually is, a private discipline for staying steady inside something too large to control.

The bottleneck was never ideas

For years I told myself the problem was that I did not have enough good ideas. That was never true. The ideas show up fine, usually in the worst possible moment, in the car or mid walk or right before sleep. The problem was the desk. The capturing, the sorting, the writing up, the filing, the remembering where I put it. The structure work. By the time I sat down to do it the energy was gone and the idea had gone cold, and I called that a discipline problem when it was a friction problem.

One of the things I keep coming back to about complexence is that you cannot hold the whole system in your head and you were never supposed to. You build the map outside your head so the head is free to do the part only it can do. Complexence OS is that move, made literal. It is the externalized half of the capability. The machine holds the structure so I can spend myself on judgment instead of filing.

How it actually works

The shape is small on purpose.

voice in  ->  one router  ->  specialist roles  ->  durable artifacts  ->  weekly review

You capture by speaking into a dated inbox file. You route the whole inbox through one prompt, a Chief of Staff. It does not try to be clever. It cleans each spoken entry into readable prose without changing your words, classifies every item, scores how sure it is, and either handles the item or hands it to a specialist. Then it writes one daily brief with five sections: your top three, what it processed, what is waiting on you, what is blocked, and one forward action. You read the top three and the blockers. You ignore the rest, because the rest is done.

Behind the router is a capped set of specialist roles, six to start. One maps the terrain of my repositories so I can see what changed. One drafts and stages writing. One keeps a census of the system. One plays critic. None of them act on the world without me. The cap matters as much as the roles. The temptation with agents is to keep adding them until you have a committee you now have to manage, and a committee is just complexity wearing a helpful face. Six roles I can name and trust beats twenty I have to supervise. A few of them are barely past a prompt and a hope right now. On day one that is fine. The shape is the point, and the shape held.

The reviewing is the discipline, and it is deliberately tiny. A five section brief, mostly blockers. If I am tired, capture is enough, and the system tolerates a day or two of lag without breaking. The point of the whole design is that on my worst day the obligation is still just: talk into the file, save.

The rule that makes it safe to hand over

The reason I will let an agent run unattended is that it physically cannot do the dangerous things. When the Chief of Staff runs on its own, it has file tools and nothing else. No posting, no pushing, no deploying. If I ask it to publish something, it does not publish. It stages the thing privately and leaves me a single yes or no decision. Going public is always me, by hand, on purpose.

That is the line the whole system is built around, and it is the same instinct as the antifragile one. Let the machine take the volatility you do not want, the drudgery and the filing and the first draft, and keep for yourself the few moves that are irreversible. Automate the recoverable. Gate the permanent. An assistant you have to watch every second is not saving you anything. One that is structurally incapable of the catastrophic case is a different kind of tool.

Why I made the method public

I open sourced the method, not my life. The public repository, OrganicArtsLLC/complexence, holds the specification, the role prompts, and blank templates. It does not hold a single one of my captures or outputs. Those live in a private instance the repository is built to keep out, with a guard that refuses to commit your real data. The method is the part that generalizes. The data is the part that never should.

The prose is licensed CC BY 4.0 and the scripts are MIT, so you can take it, adapt it, run it at work or for a project, and change only the nouns: your own categories, your own arenas, what a finished artifact means to you. I did not want to ship an app. Apps decide for you. This is a method you instantiate, which means you stay in charge of the shape of it.

The honest reason it is public is that complexence is trained, not issued, and the training goes faster when the scaffolding is already standing. I spent a long time building the trellis. There is no reason you should have to build the same one from scratch before you get to the part that actually grows you.

What it is really for

I did not build this to be productive in the magazine sense. I built it because the world keeps getting more complex and I refuse to answer that by making myself smaller. The machine is not the point. The capability is the point. The machine just clears the desk so the capability has room.

You talk. One agent sorts it. You review only what truly needs you. Everything else becomes a durable artifact you can find later, and when the loop holds, it closes on its own. That is the externalized half of standing inside complexity without coming apart. I keep the judgment. The system keeps the structure.

This is day one. For a couple of years my work has been AI assisted, me at the keyboard with a fast helper at my elbow. Tonight it crossed into something else: me directing a small set of agents and reviewing what they hand back. From AI assisted to agent director, in one tired evening, with a setup that half works and a year-old Slack app holding part of it together. It will grow and get less brittle over the coming days, and I will post a followup when it has earned one. The direction is what I wanted to mark. It starts, still, with me talking into a file and saving.

How I am actually doing it

None of this is fancy, and that is the point. The whole thing runs on one Mac at home. Capture is dumb and local. I hit an iOS Shortcut on my phone, talk, and it drops the recording into a Shortcuts folder in iCloud. A small loop on the Mac watches that folder, and when a new memo lands a local Whisper model (faster-whisper, the small English model, on the CPU, no cloud and no API) turns it into text and writes it into the day's note. The thing that hears me never leaves the machine. That voice path is one of the two ways in. The other is typing to Marcus in Slack, for the times I would rather not talk. Two different doors, the same route, the same place it ends up.

The piece I did not expect to need was Slack. Partway through I realized a capture-only loop is half a loop. If the system can take what I say but cannot say anything back, I am still tied to a terminal to find out what it did. So I wired in a Slack app I built last year and never finished, two-way, over Socket Mode. Now the loop talks back. It DMs me the brief and the blockers, and I can DM it a new thought from my phone without opening a terminal or even speaking. That one change is what turned it from a script I run into a thing I have a conversation with.

The rest, for now, is held together with tape, and I am fine saying so. I reach the Mac from my phone over Tailscale, a small private network, with Termius as the terminal. The session drops on me constantly, which is half the reason the Slack back channel matters as much as it does. I keep meaning to live inside tmux so the work survives a disconnect, but its scrolling fights me, so for now I just reopen Termius and resume the agent session where it died, and I have learned to tell the agent to run anything long as its own detached process so a dropped phone connection cannot kill it halfway. It is day one, and it looks like day one. This very post got staged that way, by an agent that finished the job after my session had already fallen over.

So there are two ways in, voice and Slack, and they both land in the same place: one dated markdown file that gets written once and is never edited after. Everything downstream, the briefs, the artifacts, the dashboards, is derived from that one file. Two inputs, one source of truth, written once. That rule is boring, and it is the whole reason I trust the thing not to quietly rewrite its own memory.

I know there are a dozen better ways to build this, and people who would do it cleaner in an afternoon. That is fine. This is iteration one, my first rough pass at it, and I like the spirit of the thing more than I am bothered by the seams. Mostly I am just excited about what comes next.