orchestrating-parallel-agents
Spawns multiple AI coding agents to work on related GitHub issues concurrently using git worktrees. Use when breaking down a large feature into multiple issues, running parallel agents with --print flag, or managing wave-based execution of related tasks.
Best use case
orchestrating-parallel-agents is best used when you need a repeatable AI agent workflow instead of a one-off prompt. It is especially useful for teams working in multi. Spawns multiple AI coding agents to work on related GitHub issues concurrently using git worktrees. Use when breaking down a large feature into multiple issues, running parallel agents with --print flag, or managing wave-based execution of related tasks.
Spawns multiple AI coding agents to work on related GitHub issues concurrently using git worktrees. Use when breaking down a large feature into multiple issues, running parallel agents with --print flag, or managing wave-based execution of related tasks.
Users should expect a more consistent workflow output, faster repeated execution, and less time spent rewriting prompts from scratch.
Practical example
Example input
Use the "orchestrating-parallel-agents" skill to help with this workflow task. Context: Spawns multiple AI coding agents to work on related GitHub issues concurrently using git worktrees. Use when breaking down a large feature into multiple issues, running parallel agents with --print flag, or managing wave-based execution of related tasks.
Example output
A structured workflow result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.
When to use this skill
- Use this skill when you want a reusable workflow rather than writing the same prompt again and again.
When not to use this skill
- Do not use this when you only need a one-off answer and do not need a reusable workflow.
- Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/orchestrating-parallel-agents/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How orchestrating-parallel-agents Compares
| Feature / Agent | orchestrating-parallel-agents | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Spawns multiple AI coding agents to work on related GitHub issues concurrently using git worktrees. Use when breaking down a large feature into multiple issues, running parallel agents with --print flag, or managing wave-based execution of related tasks.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Orchestrating Parallel Agents
Spawn multiple Claude agents to work on related issues concurrently using git worktrees.
## Philosophy
- **Issues ARE the prompts** - Write issues with enough context for autonomous work
- **Maximize parallelism** - Group independent work into waves
- **Fail fast** - Complete git/PR manually if agents can't
- **Trust but verify** - Review diffs, resolve conflicts manually
## Workflow Checklist
Copy and track progress:
```
Parallel Agent Orchestration:
- [ ] 1. Break feature into issues (1-3 files each)
- [ ] 2. Organize into waves (independent → dependent)
- [ ] 3. Pre-approve git permissions in settings.local.json
- [ ] 4. Spawn wave with --print flag
- [ ] 5. Monitor progress
- [ ] 6. Complete stragglers manually
- [ ] 7. Merge PRs (rebase between same-file conflicts)
- [ ] 8. Cleanup worktrees
```
## Issue Template
Each issue should be completable in isolation:
```markdown
## Problem
What's broken or missing.
## Solution
High-level approach.
## Files to Modify
- `path/to/file` - what changes
## Implementation
Code snippets or pseudocode.
## Acceptance Criteria
- [ ] Testable outcomes
```
**Key:** Include file paths and code examples. Agents work best with concrete starting points.
## Wave Organization
```
Wave 1: Independent changes (no shared files)
Wave 2: Changes that may touch same files (expect conflicts)
Wave 3: Integration/testing (depends on all above)
```
**Rule:** Same-file issues go in different waves OR same agent.
## Pre-approve Permissions
Add to `.claude/settings.local.json` for non-interactive `--print` mode:
```json
"Bash(git -C /absolute/path/to/worktree add:*)",
"Bash(git -C /absolute/path/to/worktree commit:*)",
"Bash(git -C /absolute/path/to/worktree push:*)"
```
## Spawn Agents
```bash
for issue in 101 102 103; do
(claude --print "/worktree-issue $issue" > "issue-${issue}.log" 2>&1) &
done
```
## Monitor
```bash
ps aux | grep "claude.*worktree" | wc -l # Running agents
git worktree list # Worktrees created
tail -f issue-*.log # Live logs
```
## Complete Stragglers
If agent finishes code but fails on git:
```bash
git -C <worktree> add -A
git -C <worktree> commit -m "feat: description"
git -C <worktree> push -u origin <branch>
gh pr create --head <branch> --title "..." --body "Closes #N"
```
## Merge with Conflicts
```bash
gh pr merge N --squash --delete-branch
```
If conflicts after prior merges:
```bash
cd <worktree> && git fetch origin main && git rebase origin/main
# resolve conflicts
git push --force-with-lease
```
## Cleanup
```bash
git worktree remove <path>
git branch -D <branch>
git worktree prune
```
## Quick Reference
| Tip | Why |
|-----|-----|
| 1-3 files per issue | Higher success rate |
| Include "Files to Modify" | Agents find code faster |
| Backend-first waves | Fewer frontend conflicts |
| Merge same-file PRs sequentially | Rebase between each |
| Problem | Solution |
|---------|----------|
| Agent stuck on permissions | Complete git manually |
| Merge conflict | Rebase, resolve, force-push |
| Agent went off-scope | Reject PR, clarify issue |
| Too many conflicts | Smaller waves, sequential merge |Related Skills
voice-agents
Voice agents represent the frontier of AI interaction - humans speaking naturally with AI systems. The challenge isn't just speech recognition and synthesis, it's achieving natural conversation flow with sub-800ms latency while handling interruptions, background noise, and emotional nuance. This skill covers two architectures: speech-to-speech (OpenAI Realtime API, lowest latency, most natural) and pipeline (STT→LLM→TTS, more control, easier to debug). Key insight: latency is the constraint. Hu
m365-agents-ts
Microsoft 365 Agents SDK for TypeScript/Node.js. Build multichannel agents for Teams/M365/Copilot Studio with AgentApplication routing, Express hosting, streaming responses, and Copilot Studio client integration. Triggers: "Microsoft 365 Agents SDK", "@microsoft/agents-hosting", "AgentApplication", "startServer", "streamingResponse", "Copilot Studio client", "@microsoft/agents-copilotstudio-client".
m365-agents-py
Microsoft 365 Agents SDK for Python. Build multichannel agents for Teams/M365/Copilot Studio with aiohttp hosting, AgentApplication routing, streaming responses, and MSAL-based auth. Triggers: "Microsoft 365 Agents SDK", "microsoft_agents", "AgentApplication", "start_agent_process", "TurnContext", "Copilot Studio client", "CloudAdapter".
m365-agents-dotnet
Microsoft 365 Agents SDK for .NET. Build multichannel agents for Teams/M365/Copilot Studio with ASP.NET Core hosting, AgentApplication routing, and MSAL-based auth. Triggers: "Microsoft 365 Agents SDK", "Microsoft.Agents", "AddAgentApplicationOptions", "AgentApplication", "AddAgentAspNetAuthentication", "Copilot Studio client", "IAgentHttpAdapter".
hosted-agents-v2-py
Build hosted agents using Azure AI Projects SDK with ImageBasedHostedAgentDefinition. Use when creating container-based agents that run custom code in Azure AI Foundry. Triggers: "ImageBasedHostedAgentDefinition", "hosted agent", "container agent", "create_version", "ProtocolVersionRecord", "AgentProtocol.RESPONSES".
computer-use-agents
Build AI agents that interact with computers like humans do - viewing screens, moving cursors, clicking buttons, and typing text. Covers Anthropic's Computer Use, OpenAI's Operator/CUA, and open-source alternatives. Critical focus on sandboxing, security, and handling the unique challenges of vision-based control. Use when: computer use, desktop automation agent, screen control AI, vision-based agent, GUI automation.
azure-ai-agents-persistent-java
Azure AI Agents Persistent SDK for Java. Low-level SDK for creating and managing AI agents with threads, messages, runs, and tools. Triggers: "PersistentAgentsClient", "persistent agents java", "agent threads java", "agent runs java", "streaming agents java".
azure-ai-agents-persistent-dotnet
Azure AI Agents Persistent SDK for .NET. Low-level SDK for creating and managing AI agents with threads, messages, runs, and tools. Use for agent CRUD, conversation threads, streaming responses, function calling, file search, and code interpreter. Triggers: "PersistentAgentsClient", "persistent agents", "agent threads", "agent runs", "streaming agents", "function calling agents .NET".
autonomous-agents
Autonomous agents are AI systems that can independently decompose goals, plan actions, execute tools, and self-correct without constant human guidance. The challenge isn't making them capable - it's making them reliable. Every extra decision multiplies failure probability. This skill covers agent loops (ReAct, Plan-Execute), goal decomposition, reflection patterns, and production reliability. Key insight: compounding error rates kill autonomous agents. A 95% success rate per step drops to 60% b
ai-agents-architect
Expert in designing and building autonomous AI agents. Masters tool use, memory systems, planning strategies, and multi-agent orchestration. Use when: build agent, AI agent, autonomous agent, tool use, function calling.
agents-v2-py
Build container-based Foundry Agents using Azure AI Projects SDK with ImageBasedHostedAgentDefinition. Use when creating hosted agents that run custom code in Azure AI Foundry with your own container images. Triggers: "ImageBasedHostedAgentDefinition", "hosted agent", "container agent", "Foundry Agent", "create_version", "ProtocolVersionRecord", "AgentProtocol.RESPONSES", "custom agent image".
testing-skills-with-subagents
Use when creating or editing skills, before deployment, to verify they work under pressure and resist rationalization - applies RED-GREEN-REFACTOR cycle to process documentation by running baseline without skill, writing to address failures, iterating to close loopholes