$ man context-wiki/parallel-agents

Parallel agents means running multiple AI agents at the same time on different tasks. Not sequentially. Not one after another. All at once. The key word is independent. If Agent A needs the output of Agent B, they cannot run in parallel. If they touch different files, different data, different concerns, launch them all at once. This is the single biggest speed multiplier in AI-assisted development. A task that takes 45 minutes sequentially can finish in under 10 minutes with parallel agents.

PATTERN

Before launching parallel agents, check three things for each pair of tasks: 1. Do they write to the same files? If yes, they cannot run in parallel. File conflicts will corrupt output. 2. Does one need the output of the other? If yes, they must run sequentially. The dependent task runs after the first completes. 3. Do they import from something that does not exist yet? This is trickier. If Agent A creates a data file and Agent B imports from it, they seem dependent. But if Agent B is copying a known pattern (like mirroring an existing wiki page), it can run in parallel because the import structure is predictable even before the file exists. If all three checks pass, launch them in parallel. If any fail, sequence them.

PRO TIP

When I built the Clay Wiki, I ran 5 parallel agents. Agent 1 wrote the data file (the heavy lift, all the content). Agent 2 built the hub page (list of all entries). Agent 3 built the entry page (individual wiki articles). Agent 4 updated exports, navigation, and cross-links. Agent 5 verified the build. They all worked on different files. None of them needed to wait for another. Agents 2 and 3 imported from the data file that Agent 1 was creating, but they mirrored a known pattern (the existing knowledge pages) so the import structure was predictable. That cut a 45-minute sequential task to under 10 minutes. Five agents, five files, one build.

PATTERN

Not every parallel agent needs the same model. The orchestration agent (the one that launched the others) should use the default model for coordination and complex reasoning. Sub-agents doing straightforward copy-paste-and-adapt work can use fast models. Sub-agents doing the heavy creative lift (writing 17 wiki entries, for example) should use the default or more capable model. The formula: complexity of the individual task determines the model. Parallelism determines the speed. Combine fast models on simple tasks with capable models on hard tasks, and you get both speed and quality.

ANTI-PATTERN

Not everything should run in parallel. If you launch 5 agents and 3 of them need to modify the same file, you get merge conflicts and corrupted output. If you launch an agent to build a page before the data file exists and the agent cannot predict the structure, it will hallucinate the imports and fail at build time. Parallel agents work when tasks are truly independent. When they are not, sequencing is not slow. It is correct. The speed gain from parallelism is real, but only when the independence test passes. Forcing parallelism on dependent tasks creates more work, not less.

FORMULA

1. Plan first. Use plan mode to identify all tasks and their dependencies. 2. Group independent tasks. These are your parallel candidates. 3. Sequence dependent tasks. These run after their dependencies complete. 4. Assign models. Fast model for simple tasks, default model for complex tasks. 5. Give each agent specific context. Do not assume they share context with each other. Each agent gets its own instructions and file references. 6. Verify after all agents complete. Run the build. Check the output. Parallel agents can each succeed individually but fail collectively if the plan was wrong.