Parallel agents are key to productivity

I'm of the opinion that parallel and background agents are key to how agentic coding improves our productivity. "How do I productively get to 2 parallel agents?" "Juggle 4 agents?" "Coordinate 10+ agents?"

I enjoy discussing with other engineers about how they use AI. One of the most common questions I hear when I speak to engineers is: "how do I improve my AI skills?" A very broad question, but a core sentiment we've been feeling.

My answer was often along the lines of: "Figure out how to run parallel agents, then do it better. Then figure out the bottlenecks, then try to parallelize it better."

How do you get started with parallel agents?

It's as simple as opening up a new terminal tab, and a new Claude/Codex instance. Or spinning up a new Agent in Cursor.

You can go further, by using multiple git worktrees so your agents have their own copy of the code to edit and configure your environment to run parallel instances of your application.

After coding with multiple agents in parallel, you'll run into an issue where you can't test code simultaneously. To do this, you can configure your app so each agent can run multiple copies of the application in isolation.

And a useful rule of thumb to keep mind: the longer you can run your agent unattended, the more opportunities you create for yourself to manage more agents. You can do this by enabling automatic permission review in Claude or Codex so tool call approvals don't block agent execution. Or you can create markdown plans that you review before implementation, which I still find that I trust more.

Tokenmaxxing vs productivity

A quick note on tokenmaxxing. From mid 2025 to early 2026, it was used as a proxy for productivity. I think that an underlying theme to tokenmaxxing was actually parallelism. The more you parallelized, the more tokens you burned. Theoretically this was increasing your velocity.

So while tokenmaxxing is a contentious topic, it was an arbitrary metric that helped push folks to consider new paradigms. So I actually think it's a useful metric kind of like as thought experiment, but one that you shouldn't take too seriously.

But the tokenmaxxing phase is ebbing, so it's useful to look towards better metrics.

How do I track parallelism?

I'm building Branchmore, a vibe coding observability tool that tracks tokens and records sessions. In Branchmore, there are a few ways you can track how many parallel agents you're using, and challenge yourself to go further.

Beyond dashboards about parallelism that you can track and share with friends, you can also set weekly goals for parallelism or long-running agents to try to hit and improve on.

There's also a lightweight safety checker that looks for dangerous commands so you have peace of mind your agent do anything too crazy. The idea is that safeguards give you peace of mind as you give your agents more autonomy.

If you have any questions about Branchmore or about how to adopt parallel agents, I'm happy to answer questions on LinkedIn or on X.