Skip to content
Skills Library
AI & agents · Automation

parallel-orchestrator

/parallel-orchestrator

Orchestrate parallel agent workflows using Wipnote's ParallelWorkflow. Activate when planning multi-agent work, using Task tool for sub-agents, or coordinating concurrent feature implementation.

Repository
htmlgraph ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Orchestrate parallel agent workflows using Wipnote's ParallelWorkflow. Activate when planning multi-agent work, using Task tool for sub-agents, or coordinating concurrent feature implementation.

Original author description

Orchestrate parallel agent workflows using Wipnote's ParallelWorkflow. Activate when planning multi-agent work, using Task tool for sub-agents, or coordinating concurrent feature implementation.

How it works

  1. When to Activate This Skill
  2. Core Principle: 6-Phase Parallel Workflow
  3. Phase 1: Pre-Flight Analysis (REQUIRED)
  4. Phase 2: Context Preparation
  5. Phase 3: Dispatch with Task Tool
  6. Phase 4: Monitor (During Execution)
  7. Phase 5: Aggregate Results
  8. Phase 6: Validate
  9. Optimal Tool Patterns
  10. When NOT to Parallelize
Original SKILL.md headings · 321 lines, 1,021 words
SKILL.md preview
---
name: parallel-orchestrator
description: Orchestrate parallel agent workflows using Wipnote's ParallelWorkflow. Activate when planning multi-agent work, using Task tool for sub-agents, or coordinating concurrent feature implementation.
---

# Parallel Orchestrator Skill

## When to Activate This Skill

**Trigger keywords:**
- "parallel", "concurrent", "simultaneously"
- "multiple agents", "spawn agents", "Task tool"
- "work in parallel", "parallelize"
- "speed up", "faster completion"

**Trigger situations:**
- Planning work that could run concurrently
- Multiple independent features ready to implement
- Using Claude Code's Task tool for sub-agents
- Coordinating 2+ agents on different tasks

---

## Core Principle: 6-Phase Parallel Workflow

Wipnote provides `ParallelWorkflow` for optimal parallel agent execution:

```
┌─────────────────────────────────────────────────────────────────┐
│  1. ANALYZE     →  Check dependencies, assess risks            │
│  2. PREPARE     →  Cache shared context, isolate tasks         │
│  3. DISPATCH    →  Generate prompts, spawn agents              │
│  4. MONITOR     →  Track health, detect anti-patterns          │
│  5. AGGREGATE   →  Collect results, check conflicts            │
│  6. VALIDATE    →  Verify outputs, update dependencies         │
└─────────────────────────────────────────────────────────────────┘
```

---

## Phase 1: Pre-Flight Analysis (REQUIRED)

**Always run analysis before dispatching agents!**

```python
from wipnote import SDK

sdk = SDK(agent="orchestrator")

# Method 1: Quick check
parallel = sdk.get_parallel_work(max_agents=5)
print(f"Max parallelism: {parallel['max_parallelism']}")
print(f"Ready now: {parallel['ready_now']}")

# Method 2: Full analysis with ParallelWorkflow
plan = sdk.plan_parallel_work(max_agents=3)

if plan["can_parallelize"]:
    print(f"✅ Parallelize {plan['task_count']} tasks")
    print(f"   Speedup: {plan['speedup_factor']:.1f}x")
    print(f"   Ready: {plan['ready_tasks']}")
else:
    print(f"⚠️ {plan['recommendation']}")
```

### Decision Criteria

| Condition | Action |
|-----------|--------|
| `max_parallelism >= 2` | Can parallelize |
| `len(ready_tasks) < 2` | Work sequentially |
| Shared file edits | Partition or sequence |
| `speedup < 1.5x` | May not be worth cost |

---

## Phase 2: Context Preparation

**Reduce redundant file reads by pre-caching shared context:**

```python
# Identify files ALL agents need
shared_files = [
    "src/models.py",      # Data models
    "src/config.py",      # Configuration
    "tests/conftest.py",  # Test fixtures
]

# Plan with shared context
plan = sdk.plan_parallel_work(
    max_agents=3,
    shared_files=shared_files
)
```

### What Preparation Does

1. **Reads shared files once** (not per-agent)
2. **Generates summaries** for agent context
3. **Identifies file conflicts** before dispatch
4. **Creates isolation rules** (which files each agent owns)

---

## Phase 3: Dispatch with Task Tool

**CRITICAL: Send ALL Task calls in a SINGLE message for true parallelism!**

```python
# Get ready-to-use prompts
prompts = plan["prompts"]

# CORRECT: All in one message (parallel)
for p in prompts:
    Task(
        subagent_type="general-purpose",
        prompt=p["prompt"],
        description=p["description"]
    )

# WRONG: Sequential messages (not parallel)
# result1 = Task(...)  # Wait for completion
# result2 = Task(...)  # Then next one
```

### Prompt Structure (Auto-Generated)

Each prompt includes:
```markdown
## Task: {feature_id}
Title: {title}
Priority: {priority}

## Your Assignment
{specific_instructions}

## Pre-Cached Context (DO NOT re-read these)
- models.py: Contains User, Session, Feature classes
- config.py: DATABASE_URL, API_KEY settings

## Files to AVOID (other agents editing)
- {files_assigned_to_other_agents}

## Efficiency Guidelines
- Use Grep before Read (search then read)
- Batch Edit operations
- Mark feature complete when done
```

---

## Phase 4: Monitor (During Execution)

Agents track their own health via transcript analytics:

### Health Metrics Tracked

| Metric | Healthy | Warning |
|--------|---------|---------|
| Retry rate | < 30% | > 30% |
| Context rebuilds | < 5 | > 5 |
| Tool diversity | > 30% | < 30% |
| Overall health | > 70% | < 70% |

### Anti-Patterns Detected

```python
# These patterns trigger warnings:
("Read", "Read", "Read")     # Cache instead
("Edit", "Edit", "Edit")     # Batch edits
("Bash", "Bash", "Bash", "Bash")  # Check errors
("Grep", "Grep", "Grep")     # Read results first
```

---

## Phase 5: Aggregate Results

**After all agents complete:**

```python
# Collect agent IDs from Task tool responses
agent_ids = ["agent-abc123", "agent-def456", "agent-ghi789"]

# Aggregate with SDK
results = sdk.aggregate_parallel_results(agent_ids)

print(f"Successful: {results['successful']}/{results['total_agents']}")
print(f"Health: {results['avg_health_score']:.0%}")
print(f"Speedup: {results['parallel_speedup']:.1f}x")
print(f"Conflicts: {results['conflicts']}")
print(f"Anti-patterns: {results['total_anti_patterns']}")
```

### Result Structure

```python
{
    "total_agents": 3,
    "successful": 3,
    "failed": 0,
    "total_duration_seconds": 450.0,
    "parallel_speedup": 2.3,
    "avg_health_score": 0.80,
    "total_anti_patterns": 4,
    "files_modified": ["auth.py", "api.py", "tests/..."],
    "conflicts": [],  # Empty = good!
    "recommendations": [...],
    "validation": {
        "no_conflicts": True,
        "all_successful": True,
        "healthy_execution": True,
    },
    "all_passed": True
}
```

---

## Phase 6: Validate

```python
if results["all_passed"]:
    print("✅ Parallel execution validated!")
    # Commit all changes together
else:
    # Handle issues
    for rec in results["recommendations"]:
        print(f"⚠️ {rec}")
```

---

## Optimal Tool Patterns

### DO (Efficient)

| Pattern | Why |
|---------|-----|
| `Grep → Read` | Search before reading |
| `Read → Edit → Bash` | Read, modify, test |
| `Glob → Read` | Find files first |
| Single Task message | True parallelism |

### DON'T (Anti-Patterns)

| Pattern | Problem | Fix |
|---------|---------|-----|
| `Read → Read → Read` | Redundant reads | Cache content |
| `Edit → Edit → Edit` | Unbatched | Combine edits |
| Sequential Task calls | No parallelism | Single message |
| Overlapping files | Conflicts | Isolate scope |

---

## When NOT to Parallelize

| Situation | Reason | Alternative |
|-----------|--------|-------------|
| Shared dependencies | Conflicts | Sequential + handoff |
| Tasks < 1 minute | Overhead not worth it | Sequential |
| Overlapping files | Merge conflicts | Partition files |
| Complex coordination | Risk of errors | Plan agent |

---

## Integration with Other Skills

### With `wipnote-tracker`
- Parallel agents each track their own session
- Activities attributed to features automatically
- Drift detection per agent

### With `strategic-planning`
- Use `find_bottlenecks()` before parallel dispatch
- Prioritize work that unlocks most downstream tasks
- Assess risks before large parallel batches

---

## Quick Reference

```python
from wipnote import SDK

sdk = SDK(agent="orchestrator")

# 1. Plan
plan = sdk.plan_parallel_work(max_agents=3)

# 2. Check
if plan["can_parallelize"]:
    # 3. Dispatch (all at once!)
    for p in plan["prompts"]:
        Task(prompt=p["prompt"], ...)

    # 4. Aggregate (after completion)
    results = sdk.aggregate_parallel_results(agent_ids)

    # 5. Validate
    if results["all_passed"]:
        print("✅ Success!")
```

---

## Troubleshooting

### "Not enough independent tasks"
- Check dependency graph: `sdk.get_parallel_work()`
- Resolve bottlenecks first: `sdk.find_bottlenecks()`

### High anti-pattern count
- Add shared file caching
- Review agent prompts for efficiency guidelines

### File conflicts detected
- Improve task isolation in Phase 2
- Consider sequential execution for overlapping work

### Low health scores
- Check retry rates (consecutive same-tool usage)
- Add more context to agent prompts
- Use Grep before Read pattern

Versions

RepositoryScoreLicence
This page · shakestzd/htmlgraph100MIT
shakestzd/htmlgraph100MIT

Database snapshot: 13.11.2026 · package version 1f2218a919bb (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100parallel-agents
    Multi-agent orchestration patterns for Claude Code's native Agent tool. Use when coordinating multiple specialized agents for comprehensive reviews, cross-domain feature implementation, or parallel analysis from multiple perspectives. Adapted to this workspace's 42 actual agents.
  • 90vc:team
    Orchestrate Agent Teams for parallel multi-session collaboration. Use for research, implementation, review, and debug workflows requiring independent teammates.
  • 90vc:team
    Orchestrate Agent Teams for parallel multi-session collaboration. Use for research, implementation, review, and debug workflows requiring independent teammates.
  • 100agent-context
    Defines the shared rules for wipnote coder and researcher agents: work attribution and completion, the test-first implementation workflow, safety, research routing, and persisting results. Preloaded into those agents. Use when acting as a wipnote coder or researcher agent, or…
  • 81skills
    Lists every wipnote skill, including those hidden from the skill list (planning, plan critique, UI checks, guard profiles, issue reports), and how to load each one. Use to find the right wipnote workflow before starting one.
  • 100oh-my-claudecode
    Orchestrate multi-agent Claude Code teams — assign roles, coordinate parallel tasks, share context between agents, and manage team workflows. Use when: running multiple Claude Code agents simultaneously, building team-based AI development workflows, coordinating complex multi-agent coding projects.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.