All writing
AIAgentsOrchestrationTools

I Only Talk to One Thread Now

Most of my projects now run through one orchestrator thread that starts the work, reads the reports, and only comes to me for decisions. Here is how that works, and where the hard part moved.

Max KellyNovember 15, 20265 min read
I Only Talk to One Thread Now

Earlier this evening I asked one agent to do three things.

Clean up this website. Draft new posts for this blog. Update my personal site.

It started three threads, one for each job. Each thread got its own machine, its own branch, and its own pull request. They worked at the same time, and none of them touched each other's files.

I talked to the one agent the whole time. It read the reports and came back to me only when something needed a decision.

That is how most of my projects run now.

The numbers got silly

The thread that runs reccy neuro has opened 427 pull requests since October 4. That is one thread in about six weeks.

I did not write a brief for each of those. I wrote the rules once, answered questions when it had them, and made the calls only I could make.

Everyone is talking about orchestration

Addy Osmani put the shift simply in his write-up of a talk on orchestrating coding agents:

You used to pair with one AI. Now you manage an agent team.

That matches what I see. But managing a team of agents by hand is its own full-time job. Ten terminal tabs is not a system.

So I stopped managing the team. I manage one agent, and it manages the team.

What the orchestrator does

The orchestrator I use most is a Captain in Capy. Capy's docs describe a Captain as a long-lived agent that runs other threads for you. It starts threads for the work, reads their reports, and tells you only what needs you.

In practice that comes down to four jobs.

It holds the plan. The Captain keeps its plan, its rules, and every thread's report in its own drive, so it picks up where it stopped.

It writes the briefs. A new thread starts from its brief and the shared rules. It has not seen my conversation with the Captain, so the Captain has to hand over everything the thread needs.

It reads the reports so I don't have to. When a thread finishes, the Captain reads what it did, updates the plan, and decides what comes next.

It brings me decisions, not updates. What it asks me are the things only I can answer. Approve this copy. Merge this. Pick A or B.

Anthropic says fold your subagents. I agree.

The most interesting pushback this fall came from Anthropic. On October 22 they published a guide on when to fold subagents into your main agent loop. Across several enterprise deployments, they found a single agent with skills often beat subagent designs on quality, and often cost less and ran faster.

Their warning is about agents that copy the org chart:

But too often we see enterprises give each team or problem type its own subagent, with the agent architecture becoming a copy of their org chart (Conway's law at work).

I think they are right, and it fits how I work. The same guide says subagents still make sense when "multiple tasks need to be tackled in parallel with fresh context windows that can be discarded once the task is done."

That is a pull request. It has its own branch, its own checks, and a clean result to hand back. Once it merges, the thread's context can go.

My orchestrator is the one main loop. It keeps the context that matters across tasks: the plan, the rules, what shipped, and what I decided. The threads are disposable. I split work by unit of work, never by team.

Why Capy

I have used a lot of agent tools this year. Capy is my favorite right now, for three reasons.

Every thread gets its own machine. A cloud thread runs on its own Linux VM, so several threads writing code at once never trip over each other. Threads can also run on my own computers, and move to the cloud and back.

I bring my own subscriptions. I connect the model subscriptions I already pay for, and Capy does not charge for those tokens. Machine time is still billed, which is fair.

It has taste. The interface shows me what needs me and hides the rest. That sounds small. With dozens of threads running, it is the whole product.

Where the hard part moved

Code got cheap. Briefs and decisions did not.

A vague prompt used to cost me one bad pull request. With an orchestrator, a vague rule gets copied into every thread it starts. So I spend more time on rules than I ever did on prompts.

My Arcane crew has a rules file that every thread reads before it starts. Paraphrased, a few of the rules say:

  • Never invent facts. If a claim cannot be sourced, leave it out and say so.
  • Blog drafts stay unpublished until I approve the text.
  • Never merge. Open the pull request and report back.

This post went through that crew. It started as a draft that the site would not publish, and it stayed that way until I signed off.

Merges get the same treatment. In the repo for Gecco, the code reviewer I built, a pull request does not merge until CI is green, Gecco scores it 5 out of 5, and every finding is resolved. The orchestrator enforces that. I don't have to.

Where I would start

  1. Start with one thread doing real work.
  2. When you keep asking it to start other threads, make it the orchestrator.
  3. Write your rules down once, in a file every thread reads.
  4. Give each thread one unit of work with a clean result, like a pull request.
  5. Read reports, not transcripts.
  6. Gate merges on checks, not on how confident the agent sounds.

I used to manage agents.

Now I manage one, and it manages the rest.