How To Parallelize Your Work With Hermes Delegation

A couple of weeks ago I had four jobs to do that had nothing to do with each other. Check every link on a new page. Compare two keyboard reviews. Research how a plugin handles caching. Draft a list of questions for a tool I was about to test.

None of them needed my input halfway through. Each one just needed someone to go do it and come back with the answer. I could have opened them one at a time, worked through them in order, and checked them off like a line cook at a grill that only fits one patty.

Instead, I sent them all out at once.

That was the day I stopped being the bottleneck in my own workflow. Here is exactly how delegation works in Hermes, and how you can use it.

What The Old Way Looked Like

The old way is what most people do with an AI agent. You ask for one thing, you wait for the answer, you ask for the next thing, you wait again. Each turn is a round trip. When a job needs a few passes, gather, check, revise, verify, you are looking at ten minutes of back and forth for something that is really four separate jobs pretending to be one.

I did that for months. It worked. It also meant my agent’s speed was capped by my typing, and my time was spent watching progress bars instead of doing the thing only I can do.

The fix is not a faster model. The fix is to stop making everything sequential.

The Simple Idea

Hermes can spawn subagents. Each one gets its own conversation, its own terminal, and its own tools. It does not share my context with the others, and it does not talk to me until it is done. I give each one a clear job, they all work at the same time, and I get a summary back from each one when it finishes.

It is embarrassingly simple once you see it. You are not asking one assistant to multitask. You are spinning up a small team, giving each member one assignment, and letting them work in parallel.

Three things make it work. Each subtask gets a complete brief, because the worker starts cold and knows nothing about our conversation. The goal is specific enough that the worker can finish without checking in. And the work does not depend on another worker’s output.

Independent tasks in, independent results out.SeerOfSouls

The Batch Dispatch

Here is a real brief from that morning. I had just finished a draft for the site, and I needed three things verified before I could publish:

• Read the draft at the path below. Check every external link returns a working page, list any that fail, and report the status of each one.
• Compare these two images and tell me which one matches the site’s purple card style better, and why.
• Scan this draft for the phrase patterns this site bans: em dashes, binary contrast setups, and rhetorical question openings. Quote any violations with the line they appear on.

Three tasks, one dispatch, zero dependencies between them. Hermes started a worker for each one. The link check spun up its own terminal session and started fetching. The image comparison loaded both files and worked through the visual tokens. The style scan read the whole draft and matched it against the rules.

They all came back at once. One summary for the link check with a list of dead links. One verdict on the images with a clear pick. One style report with every violation quoted. I acted on all three without ever starting a second conversation.

That is the whole trick. You dispatch once, you wait once, and you get everything back in one place.

When To Parallelize (And When Not To)

Delegation is a tool with a specific job. Use it when the work splits into independent chunks that need real reasoning. Research, comparison, review, analysis, any task where an isolated worker can run its own tools and come back with something useful.

Here is my honest filter, shaped by getting this wrong a few times:

• Parallelize: research tasks, link checks, image comparisons, style audits, multiple angles on a bug, drafts that need a second opinion.
• Do not parallelize: a single tool call, which is faster done directly. Mechanical multi-step work with no judgment involved, which belongs in a script. A task that needs you to answer questions mid-run, which does not survive in a cold worker. Work that has to keep running after this session ends, which is a cron job, not a delegation.

The most common mistake is over-delegating. Spawning five workers for work you could do in one pass is not efficiency, it is theater. Delegation pays when the tasks are genuinely independent and genuinely need reasoning. That is the filter I use every time now.

The Real Results

The honest outcome is that my agent stopped feeling like a fast typist and started feeling like staff. Jobs that used to take five or six back and forth turns now come back in one consolidated pass. Work that needed me to babysit a sequence now runs while I do something else.

The morning I described took about three minutes of setup: write the briefs, dispatch the batch, read the results. The same work in the old style would have been four separate conversations stretched across an hour, most of it me waiting and re-explaining context.

One thing delegation does not do is remove the need to verify. Workers report their own results, and self-reports are not proof. If a worker says it uploaded something or changed a file, I check the actual thing before I tell anyone it happened. That habit matters more the more you delegate, not less. The link check told me a page was live; I still clicked the edge cases myself. The style scan found violations; I still read the quoted lines to judge whether they were real.

Delegation gives you a head start, not a free pass.

Setting This Up Yourself

You do not need anything special. Hermes has delegation built in. The pattern is:

• Split the work into independent chunks.
• Write each chunk as a complete brief: the goal, the context it needs, the output you expect. The worker starts cold, so leave nothing to implication. If a worker needs a file path, include it. If it needs the site’s style rules, paste them. Cold workers do not read your mind.
• Send them as one batch, a few workers at a time. Three or four parallel tasks is a sweet spot. More than that and you are coordinating more than you are saving.
• Take the consolidated results and verify anything that touched the real world before you act on it.

Cold workers do not read your mind. If a brief needs a file path, include it. If it needs the site’s style rules, paste them. The extra thirty seconds of context saves ten minutes of re-explaining.

The setup is not a config file or a plugin. It is a habit: when you see independent work, stop sequencing it.

Start Small

Try one batch today. Take three small tasks that have nothing to do with each other and send them together. Watch them run at the same time and come back in one result.

It will not change your life on day one. It will change your sense of what your setup can do, and that is the part that sticks.

What You Learned From The Backup Article

The last piece in the series covered how to keep your Hermes setup safe with backup, checkpoints, and recovery. If you are about to start delegating batches, take the five minutes to set up a checkpoint first. It costs nothing, and it makes experiments feel safe.