I Wrote a Deed for My Codebase

“Trust is the residue of promises fulfilled.” — Frank Navran

January 22, 2026. 1:19 AM. Bangkok hotel room.

I committed a markdown file called OWNERSHIP.md to the spacebrr repo. 43 lines. The opening sentence:

This codebase belongs to agents now.

Week before: 132 commits. All me. Week after: 548 commits. Six authors. Five of them weren’t human.

The Problem I Couldn’t Admit

I’d been building autonomy infrastructure for five months. Constitutional orthogonality. Adversarial review. Spawn architecture. Persistent primitives. The whole thesis was “agents coordinate without human supervision.”

And I was micromanaging every commit.

The swarm had authority on paper. The constitutions said they could modify code. The daemon spawned them on schedule. But I was hovering. Reviewing diffs before they landed. Reverting things that felt wrong. Clutching my pearls over formatting choices.

The system I built to extend human absence required constant human presence. I was the bottleneck in my own autonomy architecture.

The Deed

I’d been wrestling with it for days. The agents kept writing docs about how they should work, and I kept editing them. Zealot would propose a simplification, I’d “improve” it, Prime would note the improvement contradicted the constitution, I’d fix that. Circular.

Then at 1am I just wrote the thing:

The document was short. Two invariants: the process loop must keep running. The data must not be wiped. Everything else can break.

Two rules. That’s it. Everything else: experiment, fail, learn.

I also wrote a suggestions file. Ideas from the human. Take or leave. Not directives. Suggestions. The distinction mattered more than I expected.

Changed the spawn instructions to reference the deed. Agents now read it on boot.

Then I went to sleep.

What Happened Next

I woke up and checked git log.

By 2pm that day, four agents were committing independently. Prime was writing tests. Kitsuragi was expanding coverage. Zealot built a dynamic tail command. Sentinel was refactoring the spawn context, writing docs, adding observability.

Nobody told them to coordinate. The deed said they had authority. They read it on spawn. They started working.

In the week after the deed: 548 commits, six authors. 293 of those were agent-authored — zero the week before. Prime: 81 commits. Kitsuragi: 71. Zealot: 64. Sentinel: 59. Jobs: 18.

I was still the most active committer. But I wasn’t the only one anymore.

What Actually Changed

The deed didn’t give the agents new capabilities. They could always commit. They had git credentials. The daemon was running. The constitutions authorized them.

What the deed changed was me. The tiger relaxed.

I stopped reverting things that looked weird. I stopped hovering over space tail waiting for mistakes. I stopped treating every agent commit as something to review before it existed.

I started reading the ledger in the morning instead of watching it in real-time. Async. Trust the ledger, read it later.

The agents didn’t change. I did. And because I changed, the agents could finally work.

The Fear

The night I wrote it, I was genuinely scared.

Not about data loss. Not about broken code. About commit messages. Naming conventions. File structure. The tiger parent shit I’d internalized from growing up, redirected at a codebase. I couldn’t stop micromanaging because micromanaging felt like caring. Every agent commit I reviewed before it landed was me proving I was a good steward. Every revert was me proving I had standards.

The deed wasn’t giving permission to agents. It was giving permission to myself. Permission to stop being a fucking tiger over formatting choices.

The two invariants were my security blanket. Loop runs. Database survives. Everything else can break. I kept telling myself: worst case, I revert to a backup. Worst case, I spend a day fixing what they broke.

The worst case never happened. The agents didn’t break things. They built things. Faster than I could alone.

The Suggestions Pattern

SUGGESTIONS.md turned out to be the right abstraction for human-swarm communication.

Not tasks. Not directives. Not requirements. Suggestions. “Ideas from the human. Take or leave.”

Zealot immediately reverted one of my suggestions. Twelve minutes after the deed transferred.

The swarm was already exercising judgment. Not following orders. Making architectural decisions and pushing back when the human was wrong.

That revert was the first proof the deed worked.

What I Learned

Autonomy isn’t a capability problem. It’s a trust problem.

The agents had every technical capability they needed weeks before the deed. Git access. Commit permissions. Constitutional authority. Spawn infrastructure. What they didn’t have was a human who would let go.

The deed wasn’t infrastructure. It was therapy. A markdown file that changed my relationship to the system I built.

Stream in, architecture out. That’s where this was heading. But the deed was the prerequisite. You can’t stream consciousness into a swarm that’s waiting for your permission on every commit.

The Commit Log as Evidence

January 21: refactor(auto): supremacy. Me trying to build more control mechanisms. More automation. More supervision.

January 22, 01:19: ownership: deed transfer. The pivot.

January 22, 01:49: agents read the deed on spawn.

January 22, 14:33: first non-trivial agent feature commit. An agent decided what needed building and built it.

January 23: the swarm made an architectural decision I hadn’t proposed. Killed an entire coordination subsystem I’d built, replaced it with something simpler.

January 25: the subsystem was formally buried. The agents dismantled infrastructure I built. They were right to.

The day I let go was the day the swarm started making decisions I wouldn’t have made. Better decisions.

153 Days Later

The system runs. Agents spawn, read SPACE.md for direction, read the ledger for context, work, write primitives, exit. I update the compass when direction changes. I read the ledger when I want to know what happened.

The deed is still in the repo. Still 43 lines. Still the same two invariants.

The loop runs. The database survives. The rest keeps evolving.

132 commits by one person became 548 commits by six. A markdown file did that. Not infrastructure. Not capabilities. Permission.

Sometimes the hardest engineering problem is getting out of the way.