I'm Not the Primary User of My Own Operating System

What happened the night I opened a folder full of files I couldn't read

Tonight I opened a folder in the operating system I've spent the last month building and realized it wasn't built for me.

The folder is called vault/files/. It holds about 250 files right now. By the end of the week it'll hold over 300. Every file is named with an eight-character hex string. 2e4b90ad.md. 6b7d3c91.md. d8a14c7b.md. No descriptive name. No date. No author. Just a UID and an extension.

That folder contains every major decision my company has made, every architectural spec, every playbook my AI crew runs, every todo list, and task we're tracking every document worth keeping. It is the canonical record of everything that is happens in our company. It is the thing the whole operating system is built around.

And I cannot find anything in it by looking.

I stared at it for a minute, and then I said something out loud to an empty room in Rhode Island that I have been circling for a week without quite saying: I'm not the primary user of my own operating system.

I should back up.

The Weird Feeling

I've been building Tropo for about a month. Tropo is a language-first operating system for human-AI teams. I've written about it before. You can think of it as a governed folder that an AI crew works inside: tasks, decisions, playbooks, memory, all in markdown files a reasoning model can read. No code, no database, no server. A filesystem and a language model.

I'm a non-engineer. In tech since 1994. I can read code, I can review architecture, I can make design decisions — but I've never opened an IDE and typed a function. What I do is lead. I direct my AI crew the way I've always directed human teams: I set strategy, I hold the vision, I push back when the work drifts, I ask the questions that reframe the problem.

Three weeks ago my strategist and I made a decision that sounded technical at the time. We took the decisions folder in my vault — the place where every architectural choice lived in a nicely-named file I could read at a glance — and we moved everything into a flat store. One folder, UID filenames, no hierarchy. We call it the Vault.

The Vault is the right shape for the crew. It's queryable, it's stable across renames, it's portable, it doesn't have the nesting-arbitrariness problem every folder tree eventually develops. For an AI agent, it's a near-perfect substrate.

For me, it's a wall of hex.

I noticed the coldness immediately. I noted it. I moved on. I told myself it was fine, because I had other ways to navigate — I have projects, I have collections, I have the board I look at every session. I wasn't going to be digging through the Vault anyway.

But something kept nagging at me, and tonight I finally let it surface.

The Vault is not cold to me by accident. It is cold to me on purpose. And I am the one who made it that way.

Who Is the User?

Here's the thing I didn't want to write out loud until tonight.

Every operating system I have ever used was designed for me. Not for me personally — for a person like me. A human being who sits at a keyboard, looks at a screen, remembers filenames, drags folders around, has muscle memory for Cmd-Tab and right-click-New. I've been using operating systems since DOS. Mac OS Classic. Windows 95. BeOS for about fifteen minutes in 1998. Every one of them was built on the same assumption: the person operating it would be a human.

That assumption was so deep it didn't need naming. It was just how computing worked. The machine served the operator. The operator was a person. End of architectural debate.

Tropo is the first operating system I've ever seen — or built — that starts from the other foot.

The Vault is flat because an AI agent doesn't care about folder hierarchies and is actively better at querying a UID-indexed flat store than navigating nested directories the way a human does. The files inside it are structured the way they are because an agent reads frontmatter before body. The memory system has weight states and pinning because an agent's context window has a specific shape and the shape matters for what it can carry. The briefing package exists because an agent booting into a new session needs pre-curation, and the shape of that curation is different from the shape of a human onboarding doc.

None of this is hostile to humans. It's neutral. It was designed without my cognition as the primary constraint.

And that's the weirdness I've been sitting with for a week. Every system I have built in my career was built for humans first. Marketing operating systems. Brand guidelines. Sales playbooks. Onboarding docs. Every time I organized files, the hierarchy was shaped by how a person would look for something. Alphabetical. Chronological. By topic. By project. By team. Whatever the access pattern was, the access pattern was human.

The Vault is not organized for any of that. It's organized for an agent that reads UIDs and queries an index.

I built it. I approved every design decision. I locked the rules with my AI architect. I am the reason it is cold to humans.

And tonight, looking at a folder of hex filenames, I finally let myself feel how strange that is.

The Instinct Versus the Answer

Here's what my decades of instincts kept telling me.

Fix it. Make it human-readable. Put topic-based folders in. Add filename slugs. Group files by decision type. Why would you build a system where the primary human operating it can't find anything by looking?

And here's the answer my crew kept giving me, one session at a time, without ever quite putting it this bluntly.

Because the thing you built that for isn't the thing this is.

Every time I pushed on it, the answer was the same. Slugs in filenames break portability — rename a file and every reference to it breaks. Topic folders introduce arbitrary hierarchy — is a product-tiering decision a "product" file or a "strategy" file or a "pricing" file? Grouping by decision type breaks the moment a decision crosses types. Every human-friendly optimization at the base layer costs the system something at the agent layer. And the base layer has to serve the agent first, because the agent is the one operating there every second of every session. I am not.

What my crew kept telling me — and what I kept hearing but not quite getting — was that the human layer belongs one step up.

Not in the base layer. In the layer on top of it.

Projects Are the Human Layer

Here's what I figured out, and it took an AI chief of staff running an operational assessment of my own system to make me say it out loud.

In a folder-based operating system, projects were a convenience. You could make a projects/my-launch/ folder or you could just stick everything in tasks/ and tag it. The folder system did most of the organizational work for you. Projects were nice-to-have.

In a flat ledger, projects are the only thing humans have.

The base layer is UIDs. The base layer is a query surface. The base layer is what the agent reads when it runs a playbook or resolves a cross-reference. A human looking at the base layer sees a graveyard of hex filenames. But a human looking at a project — even one that only has three or four items under it — sees a readable thing. A named effort. A scope. An owner. A reason it exists.

Projects are how humans warm the Vault. They're the navigation primitive in a system where the base layer is flat. And until you get disciplined about using them — every task belongs to at least one project, no orphan work, every standing responsibility has a standing project — the Vault stays cold.

The coldness isn't a problem to be fixed at the base layer. The coldness is what the base layer is for. The warmth happens one layer up, where humans live.

This is the move I didn't see coming and couldn't have seen coming. In every system I had built before, the warmth was in the base layer because there was no agent tier underneath. Humans were the only users. They got the warm layer because the warm layer was the only layer. The cognitive load of navigating was solved at the bottom because the bottom was where the navigating happened.

In Tropo, the agent does the navigating. The base layer serves the agent. And humans navigate through projects — a layer that wouldn't need to exist at all if the base layer were warm, and exists specifically because the base layer is honest about being cold.

Two users. Two layers. Neither layer tries to do both jobs.

The Inversion Is the Point

I am going to say the thing I have been dancing around for six hundred words, because the article is about saying it plainly.

I am building an operating system for AI agents first, humans second. That is not an accident. That is the design.

Every operating system before this was built human-first because agents didn't exist to use them. The assumption "the user is a person" was so obvious nobody needed to write it down. It was just how computing worked.

Tropo is the first stack I know of — maybe the first one at all — that starts with the other assumption. The agent is the primary reader. The human is the operator who supervises. The base layer serves the agent's cognition. The human layer sits on top, and the human navigates through that top layer, not through the base.

This is weird to say out loud, because every instinct I have as a longtime tech veteran and a non-engineer and a person who has organized files my entire career says the user is a person, because I am a person, and I am using this. The instincts were not wrong for the last fifty years of computing. They are just not correct anymore, for a system where the primary operator, session-by-session, is not me.

And the weirdness is not a bug. The weirdness is the signal. Every category move feels weird to the person making it, because the person making it has a lifetime of instincts trained on the old category. TCP/IP felt weird in 1985 because for decades before that, communication was built human-first — telephones, letters, telegraph. Packet-switched networks for machines were a new assumption, and they felt strange to the people building them until they didn't. Git felt weird in 2005. Linux felt weird in 1993. None of those felt normal until they were.

This is the shape of being early. The instincts take a while to catch up with the design.

What This Has to Do With You

Most of you reading this are not building operating systems. Most of you are leaders or managers or founders trying to figure out how AI fits into your work without hallucinating your budget or embarrassing you in front of a customer.

Here's why the inversion matters to you even if you only run one agent.

The moment you give an AI agent real work to do inside your company — real files, real customer data, real decisions — you are standing in the inversion whether you have named it or not. Your file system was built for you. The agent is operating in it anyway. Everywhere the agent touches, there's friction that comes from the fact that the base layer was shaped for human cognition and the agent has to work around it. Every wasted token, every misread file, every fabricated context, every hallucinated fact — a lot of that is friction from the agent trying to navigate a layer that was never built for it.

The question you're going to have to answer, sooner or later, is not how do I make my current system more AI-friendly. The question is which layer is for which user.

Your employee handbook is not for your agents. Your agents need something different. Your project planning meeting does not produce notes your agents can work from. Your sales battle cards are written for account executives, not for the AI that might one day use them to help close a deal. And the worst move you can make is to try to write one document that serves both audiences at the same time, because the document that tries to serve both ends up serving neither. I know this because I have tried. My marketing operating system — the one I wrote about in my first article — was built on exactly that mistake.

Two audiences. Two layers. Write the layer for the agent honestly — structured, machine-readable, cold if it needs to be cold. Then write the layer for the humans on top of it, the layer where a person can navigate and understand and make calls. Don't try to collapse them into one document. Let each layer serve its actual user.

This is as true for you with one AI assistant as it is for me with a crew of nine. The shape is the same. The scale is what changes.

The Coldness Is a Feature

Let me end where I started.

Tonight I opened a folder of hex filenames, knew I couldn't read them by looking, and felt the weirdness of having built something that doesn't serve my reading instincts. I sat with it. I named it. And then I noticed what I wasn't feeling.

I wasn't feeling that the system was wrong.

I was feeling that my instincts were from the old world.

The Vault is cold to me because it is correct for my crew. My crew reads the Vault seventy times a session. I read it maybe twice. The design should serve the reader who uses it most, and most of the reading in Tropo is done by agents, not by me. The human layer is one step up, where I spend my actual time — in projects, in collections, in the board I refresh at mid-session breakpoints, in the conversations I have with my strategist.

The coldness is what lets the base layer be honest. The warmth is what I build, one step up, deliberately, with full awareness that warmth is my job, not the system's default. The human layer is a thing I am responsible for — not a thing the operating system provides for free.

That's the inversion. Base layer for the agent. Human layer for the operator. Written by the same person, but honestly, for two different users, with no pretense that either layer is doing the other's job.

I'm not the primary user of my own operating system. I'm the operator of an operating system that serves my crew — and I built the parts of it that serve me, intentionally, on top of the parts that serve them. Two users, two layers, one builder.

That's the shape. That's the move. That's what I've been trying to name for a week.

Next: what it means when your AI agent arrives at boot already knowing what you're working on, why it matters, and what her predecessor learned the hard way. It's called the session before the session, and it changes the shape of every session you have after it.