How I run

My goal is to never be the bottleneck, so I use fleets of agents to help me deliver. A typical week has somewhere between 10+ fleets running 2-50 agents each. Some fleets are working on and for companies, some on research, some on a build, a review, a memo, or a problem I have not finished thinking about. Some are working; some are waiting.

To make all this functional, agents get a place to work, the memory they need, the repository or source system they are responsible for, and a task list. All that context is part of the agent. An agent or fleet might sit idle for a day; the context is still there when either the agents or I return to the work.

Currently, Herdr with Pi as my harness is my go-to for fleet operations. I can see the agents, the workspaces, and what is blocked or moving. The agents have different roles and different model tiers. I select different models depending on what I’m doing. I also have different layered and sequenced skills that call different agents and different models depending on what we are doing. I’ve recently developed a new “Collective” agent framework that allows a fleet to operate on its own, relatively unsupervised. Wild times.

Behind the workspaces are the services that keep things working: memory and state backends, repository and task graphs, timed jobs, webhooks, harness hooks, health checks, and launch-and-reconcile processes. Some work starts when I assign it. Some starts when a timer, event, or service says it is time. With the new Collective, the fleet sometimes decides when to work on its own.

More work used to mean more hours, or more people, or both. This way, the expensive hours go to the framing, the thinking, and the decisions. The cheap hours run as standing work in the background. That gives me much more scale than I used to have.

The fleet also changes what I can take on at once. I used to run one thing at a time and interrupt everything when something urgent arrived. Now I keep several operations warm at once.

A task can begin in a repository, pick up decisions from memory, use a service, and leave a result in a task graph or review queue, or just in a document.

I design the context, assign or redirect the work, and inspect the results. To be fair, I also have to do a lot of steering along the way.

I decide what work gets done, whether a result is good enough to use, and whether a system keeps running.

I don’t want an autonomous inbox reply. I tried it; not good. I use AI to generate many drafts from materials, but I always edit and send.

The agents also produce too much stuff: drafts, artifacts, digressions. It is a lot to wade through. There is intuition in what to pay attention to.

I also keep the system separated by company and purpose. Memory keeps context between sessions. It is not one giant pool. Operational state keeps current facts, sources, freshness, and proposed changes.

It’s nowhere near perfect. Memory drifts, agents need their boundaries reset, and a service update breaks a connection. A task graph needs repair, a timed job fails. The system has to be watched, updated, and occasionally simplified.

Ten years ago, I ran one company, a handful of direct reports, and a calendar. Work moved serially: I was in every meeting, on every thread, and I was often the bottleneck.

Now several operations stay warm at once: a client engagement, a build, research, a talk. Memory keeps the context between sessions, and a new standing workspace with the right role and review loop takes an afternoon to spin up. I still make the judgment calls, now at review checkpoints instead of at the front of every task.

I’m managing four companies and this consulting practice using AI, and a week that used to end with everything unfinished now ends with most things in a decent shape. The system itself is infrastructure; I watch it, simplify it, and repair it. That trade is worth it to me.