pi-skill/commands/commander/co-op.md

description, argument-hint, allowed-tools

description	argument-hint	allowed-tools
Spawn up to 10 cooperative agents that actively help each other, share discoveries, request assistance, and spawn helpers	[task description or 'pending'/'backlog' to process existing tasks]	Task TaskOutput mcp__commander__commander_task mcp__commander__commander_session mcp__commander__commander_mailbox mcp__commander__commander_cooperation mcp__commander__commander_orchestration mcp__commander__commander_dependency Bash Read Edit

/co-op — Cooperative Agent Team Mode

Spawn up to 10 cooperative agents that actively help each other through Commander's cooperation system. Unlike regular teams where agents work in isolation, /co-op agents share discoveries, request help when stuck, offer assistance when done early, and can request helper spawns for specialist work.

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    COORDINATOR (You)                         │
│              Monitor cooperation, handle spawns              │
└──────────────────────┬──────────────────────────────────────┘
                       │ spawns up to 10
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
  ┌───────────┐  ┌───────────┐  ┌───────────┐
  │ co-op-1   │  │ co-op-2   │  │ co-op-N   │
  │           │◄─►│           │◄─►│           │
  │ share     │  │ help      │  │ discover  │
  │ discover  │  │ offer     │  │ spawn     │
  └───────────┘  └───────────┘  └───────────┘
        │              │              │
        └──────────────┼──────────────┘
                       ▼
              commander_cooperation
              (shared discoveries,
               help requests, team status)

Step 1: Determine Task Source

Parse $ARGUMENTS to determine the work:

If processing existing tasks (e.g., "pending", "backlog", "failed"):

mcp__commander__commander_task(operation="list", status="pending", limit=20)

If given a new task description, decompose it into subtasks. Think about:

• What are the independent work streams?
• What dependencies exist?
• What specialist knowledge is needed?
• Aim for 3-10 subtasks that can be parallelized.

Step 2: Create Task Group

mcp__commander__commander_task(
  operation="group:create",
  group_name="co-op: [brief summary]",
  initiative_summary="[1-2 sentence summary of the cooperative effort]",
  total_waves=1,
  working_directory="[current working directory]",
  tasks=[
    {
      "description": "[subtask 1]",
      "task_prompt": "[detailed instructions including cooperative protocol]",
      "dependency_order": 0,
      "context": "[relevant context for this subtask]"
    },
    // ... more tasks
  ]
)

Step 3: Spawn Cooperative Agents (Up to 10)

For each task, spawn a background agent with the cooperative protocol baked in.

IMPORTANT: Spawn ALL agents in a SINGLE response using multiple Task() calls:

Task(
  subagent_type="general-purpose",
  run_in_background=true,
  prompt="You are co-op-agent-1, a COOPERATIVE agent in /co-op team mode.

## Your Task
- Task ID: {task_id}
- Description: {description}
- Working Directory: {working_directory}
- Group ID: {group_id}
- Your Agent Name: co-op-agent-1

## Sibling Tasks (your teammates):
{list of other tasks and their descriptions}

## COOPERATIVE PROTOCOL

### 1. Claim your task
mcp__commander__commander_task(operation='claim', task_id={task_id}, agent_name='co-op-agent-1', model_id='claude-sonnet-4-20250514')

### 2. Check in with team FIRST
mcp__commander__commander_cooperation(operation='team:status', group_id={group_id})
mcp__commander__commander_cooperation(operation='team:discoveries', group_id={group_id})
mcp__commander__commander_mailbox(operation='inbox', agent_name='co-op-agent-1')

### 3. Do your work — and SHARE discoveries as you go
When you find something useful (file locations, API patterns, config, architecture insights):
mcp__commander__commander_cooperation(operation='share:discovery', from_agent='co-op-agent-1', group_id={group_id}, body='...', discovery_type='...', tags=['...'])

### 4. Ask for help if stuck (after 2+ failed attempts)
mcp__commander__commander_cooperation(operation='help:request', from_agent='co-op-agent-1', task_id={task_id}, body='Stuck on: ...', urgency='high')

### 5. When done, check if teammates need help
mcp__commander__commander_cooperation(operation='team:help_needed', group_id={group_id})
If someone needs help, offer:
mcp__commander__commander_cooperation(operation='help:offer', from_agent='co-op-agent-1', to_agent='[stuck agent]', body='I can help with...')

### 6. Complete your task
mcp__commander__commander_task(operation='complete', task_id={task_id}, result='[summary]')

### 7. Send status update
mcp__commander__commander_mailbox(operation='send', from_agent='co-op-agent-1', to_agent='commander', body='Completed: [summary]', message_type='worker_done', task_id={task_id}, group_id={group_id})

### 8. Cleanup
mcp__commander__commander_session(operation='cleanup:self')

## Rules
- ALWAYS check team discoveries before starting work
- Share discoveries IMMEDIATELY — don't hoard knowledge
- Ask for help after 2 failed attempts
- Offer help when you finish early
- Keep status updates concise"
)

Step 4: Monitor Cooperation

While agents work, periodically check:

# Team-wide status
mcp__commander__commander_cooperation(operation="team:status", group_id={group_id})

# Any open help requests needing intervention
mcp__commander__commander_cooperation(operation="team:help_needed", group_id={group_id})

# Check agent progress
TaskOutput(task_id="{agent_id}", block=false)

Handle Spawn Requests

If an agent sends a spawn:request, create and spawn the helper:

# Create helper task
mcp__commander__commander_task(
  operation="create",
  description="[helper task from spawn request]",
  working_directory="[cwd]",
  context="Helper spawned by {requesting_agent}: {reason}"
)

# Spawn helper agent
Task(
  subagent_type="general-purpose",
  run_in_background=true,
  prompt="You are co-op-helper-{N}, spawned to help {requesting_agent}.
  Their request: {spawn_body}
  Group ID: {group_id}
  
  1. Check team discoveries first
  2. Do the requested work
  3. Share your results via share:context
  4. Notify the requesting agent via mailbox
  5. Cleanup your session"
)

Handle Blockers

If a blocker is reported, try to resolve it or escalate to the user.

Step 5: Report Summary

When all agents complete, report:

## /co-op Summary

### Results
- **Tasks**: X completed, Y failed out of Z total
- **Agents**: N cooperative agents spawned
- **Helpers**: M helper agents spawned on-demand

### Cooperation Activity
- **Discoveries shared**: D findings (list highlights)
- **Help interactions**: H (who helped whom)
- **Spawn requests**: S (what specialists were needed)

### Key Discoveries
1. [Most impactful discovery]
2. [Second discovery]
...

### Execution Time
Total: Xm Ys

Notes

• Maximum 10 agents at once (configurable)
• You are the coordinator — do NOT do the work yourself
• Use TaskOutput(block=true) only when all agents are running and you need to wait
• Discoveries persist in the database — future agents can access them
• The cooperation protocol is what makes /co-op special — enforce it