How My AI Agent Org Evolved as the Work Got Real
I started by trying to get useful work done without stuffing everything into one assistant-shaped blob.
As the system got more real, one problem kept showing up: ambiguity.
Who owned what? Which agent was supposed to think commercially? Which one was supposed to package work into content? Which one was supposed to handle personal operations versus revenue versus strategy?
At first, that ambiguity was tolerable. Then it slowed everything down.
So I changed the org.
This post is about what changed, why, and what got better once roles became explicit.
The first version: functional, but blurry
The early multi-agent setup already worked better than one giant chat. Different domains had different homes. Context stayed cleaner. Delegation got easier.
But a common problem: some agents were carrying too many kinds of responsibility at once.
That creates a predictable failure mode. An agent can look productive while making the overall system harder to reason about. Strategy, execution, packaging, and maintenance bleed together. Output may still be decent, but ownership gets fuzzy.
Once that happens, simple questions become hard to answer:
- Who owns this task?
- Who should follow up?
- Who should be making the tradeoff here?
- Which part of the system is overloaded?
That was the point where the org needed to become more explicit.
The real shift: from "capable agents" to "clear ownership"
This is one of the biggest differences between an AI toy setup and an AI operating system.
At small scale, capability matters most. You just want something that works.
At larger scale, ownership matters more.
A specialist agent is useful partly because it knows a narrower domain. But the bigger win is that it becomes the obvious owner of a certain category of work.
That changes the whole system. Work stops bouncing around as much. Reviews get easier. Drift gets more visible. When something is missing, you can tell whether the answer is better instructions, a better boundary, or a new role.
The current org structure
At the top level:
- Will: founder, final authority on irreversible decisions
- Mimir: managing director and orchestrator
- Harbor: life admin and personal operations
- Vector: career strategy and market narrative
- Ledger: finance and capital stewardship
- Forge: ventures, revenue systems, business execution
- Quill: content execution, editorial packaging, repurposing
- Hermes: external execution capacity when technical throughput is needed
That may look elaborate. In practice, it's less confusing than the blur that came before.
Each role exists to change behavior. If a title doesn't change who owns the work, it's decoration.
Why Quill had to exist
The cleanest example is content.
Before Quill, content risked becoming a side responsibility inside Forge. Efficient-sounding, but it creates a subtle problem: venture-building and content execution are related, but they're not the same job.
Forge should care about commercial direction, offers, revenue systems, and where content fits strategically. Quill should care about whether the content is sharp, publishable, well-packaged, proof-driven, and consistent.
Different kinds of thinking.
Once content became its own function:
- drafts got cleaner
- editorial voice got more deliberate
- repurposing became easier
- the path from proof to publishable asset got shorter
That's the kind of split the org should make on purpose.
Why Hermes isn't a peer role
Another change worth noting: clarifying Hermes.
Hermes is useful, but not in the same way the standing specialists are useful. Hermes is execution capacity: technical throughput, implementation bandwidth, contractor-style fulfillment when a task needs engineering depth.
That matters because it keeps the org honest. Not every useful capability needs to become a peer executive role. Some are better treated as managed execution bandwidth.
That framing makes planning cleaner.
What improved after the change
Review became easier
When roles are explicit, it's easier to tell whether the output is right for the owner. A content draft can be judged as content. A venture page can be judged as a venture asset. A financial note can be judged as finance.
Obvious-sounding, but it reduces a lot of noise.
Task routing got cleaner
The more the system resembles real ownership boundaries, the less work gets routed by vibe. That matters once there are multiple active projects, multiple agents, and a real backlog.
The org became easier to explain
Underrated. A system that only makes sense inside one person's head is harder to maintain and harder to share. Once the org structure got clearer, it also became easier to write about, audit, and improve.
Content got closer to proof
The content-specific upside. When there's a dedicated content function, it becomes easier to turn real system changes into builder-diary style writing instead of generic opinion pieces.
What I'm still watching
Not a finished philosophy. A working system.
A few things still need watching:
- whether the boundaries stay real or start drifting again
- whether content stays grounded in observed behavior rather than theory
- whether the org keeps improving throughput instead of just adding structure
- whether the system produces clearer proof, not just more internal complexity
The last point matters a lot. The goal is to make the work easier to run, not to make the org more clever.
Why this matters
I don't think most people need a complicated AI org chart.
But I do think most serious builders eventually run into the same problem: once the system starts doing real work, blurry ownership becomes expensive.
That's what drove this change. The org evolved because the work demanded clearer boundaries.
In practice, that made the system feel less artificial and more operational.
Read next: Why Specialist AI Agents Beat One Big Chat and Building an AI Second Brain With OpenClaw.