SpawnParallelAgents Workflow

Launches multiple parallel agents for grunt work - same task, different inputs.

Voice Notification

curl -s -X POST http://localhost:8888/notify \
  -H "Content-Type: application/json" \
  -d '{"message": "Running the SpawnParallelAgents workflow in the Agents skill to launch agents"}' \
  > /dev/null 2>&1 &

Running SpawnParallelAgents in Agents...

When to Use

{PRINCIPAL.NAME} says:

• "Launch 5 agents to research these companies"
• "Spin up agents to process this list"
• "Create agents to analyze these files" (no "custom")

KEY: No "custom" keyword = simple parallel workers for grunt work (fast execution)

NOT the same as custom agents - for unique personalities/voices/colors, use the CreateCustomAgent workflow.

The Workflow

Step 1: Identify Task List

Extract what needs to be done in parallel:

• List of companies to research
• Files to analyze
• URLs to check
• Data points to investigate

Step 2: Create Task-Specific Prompts

Each agent gets a DETAILED prompt with FULL CONTEXT and TIMING SCOPE:

const agent1Prompt = `
## Context
We're researching competitors in the AI security space for strategic planning.

## Current State
We have 10 companies identified. You're analyzing Company A.

## Task
1. Research Company A's recent product launches (last 6 months)
2. Identify their target market and positioning
3. Note any key partnerships or acquisitions
4. Assess their technical approach

## Success Criteria
- Specific product names and launch dates
- Clear target market definition
- List of partnerships with dates
- Technical stack/approach summary

## Scope
Timing: STANDARD — focused implementation.
- Under 1500 words
- Stay on task, minimal tangents
- Deliver the work, verify it works

Company A: Acme AI Security Corp
`;

Step 3: Launch ALL Agents in SINGLE Message

CRITICAL: Use ONE message with MULTIPLE Task calls for true parallel execution:

// Send as a SINGLE message with all Task calls:
Task({
  description: "Research Company A",
  prompt: agent1Prompt,
  subagent_type: "general-purpose",
  model: "haiku"  // or "sonnet" depending on complexity
})
Task({
  description: "Research Company B",
  prompt: agent2Prompt,
  subagent_type: "general-purpose",
  model: "haiku"
})
Task({
  description: "Research Company C",
  prompt: agent3Prompt,
  subagent_type: "general-purpose",
  model: "haiku"
})
// ... up to N agents

All agents run simultaneously and return results together.

Step 4: Spotcheck Results (Mandatory)

ALWAYS launch a spotcheck agent after parallel work completes:

Task({
  description: "Spotcheck parallel results",
  prompt: `Review these research results for consistency and completeness:

Company A: [results]
Company B: [results]
Company C: [results]

Check for:
1. Missing information across any companies
2. Inconsistent data formats
3. Obvious gaps or errors
4. Recommendations for follow-up research

Provide a brief assessment and any issues found.`,
  subagent_type: "general-purpose",
  model: "haiku"
})

Timing & Model Selection

Timing flows from the Algorithm. The main agent validates a timing tier (fast|standard|deep) in the THINK phase. Every agent prompt MUST include a ## Scope section:

Choose model based on timing tier AND task complexity:

Parallel execution especially benefits from haiku - spawning 10 haiku agents is both faster AND cheaper than 1 opus agent doing sequential work.

Example: Research 5 Companies

{PRINCIPAL.NAME}: "Launch agents to research these 5 AI security companies"

{DAIDENTITY.NAME}'s Execution:

// Single message with 5 Task calls:
Task({
  description: "Research Acme AI Security",
  prompt: "Research Acme AI Security Corp: products, market, partnerships, tech stack",
  subagent_type: "general-purpose",
  model: "sonnet"
})
Task({
  description: "Research Bolt Security AI",
  prompt: "Research Bolt Security AI: products, market, partnerships, tech stack",
  subagent_type: "general-purpose",
  model: "sonnet"
})
Task({
  description: "Research Cipher AI Defense",
  prompt: "Research Cipher AI Defense: products, market, partnerships, tech stack",
  subagent_type: "general-purpose",
  model: "sonnet"
})
Task({
  description: "Research Delta Threat Intel",
  prompt: "Research Delta Threat Intelligence: products, market, partnerships, tech stack",
  subagent_type: "general-purpose",
  model: "sonnet"
})
Task({
  description: "Research Echo AI Protection",
  prompt: "Research Echo AI Protection Systems: products, market, partnerships, tech stack",
  subagent_type: "general-purpose",
  model: "sonnet"
})

// After results return, spotcheck:
Task({
  description: "Spotcheck company research",
  prompt: "Review these 5 company research results for consistency and gaps: [results]",
  subagent_type: "general-purpose",
  model: "haiku"
})

Result: 5 agents research in parallel, spotcheck validates consistency.

Common Patterns

Pattern 1: List Processing

Input: List of items (companies, files, URLs, people) Action: Create one agent per item, identical task structure Model: haiku for simple tasks, sonnet for analysis

const items = ["Item1", "Item2", "Item3", "Item4", "Item5"];

// Single message with all agents:
items.forEach(item => {
  Task({
    description: `Process ${item}`,
    prompt: `Analyze ${item} for: [criteria]`,
    subagent_type: "general-purpose",
    model: "haiku"
  });
});

Pattern 2: Multi-File Analysis

Input: Multiple files to analyze Action: One agent per file, same analysis criteria Model: sonnet for code analysis, haiku for simple checks

const files = ["src/auth.ts", "src/db.ts", "src/api.ts"];

// Single message:
files.forEach(file => {
  Task({
    description: `Analyze ${file}`,
    prompt: `Review ${file} for security issues, focusing on: [checklist]`,
    subagent_type: "general-purpose",
    model: "sonnet"
  });
});

Pattern 3: Data Point Investigation

Input: Multiple data points/questions Action: One agent per question, independent research Model: sonnet for research, haiku for fact-checking

const questions = [
  "What is OpenAI's current revenue?",
  "How many employees does Anthropic have?",
  "What's Google's AI chip roadmap?",
  "When is GPT-5 releasing?",
  "What's the latest on AI regulation in EU?"
];

// Single message:
questions.forEach(q => {
  Task({
    description: `Research: ${q}`,
    prompt: `Find reliable answer to: ${q}. Include sources.`,
    subagent_type: "general-purpose",
    model: "haiku"
  });
});

Spotcheck Pattern (Mandatory)

WHY: Parallel agents may produce inconsistent formats, miss details, or have conflicting information.

WHEN: After EVERY parallel agent batch completes

HOW:

Task({
  description: "Spotcheck results",
  prompt: `Review these parallel results:

[Agent 1 results]
[Agent 2 results]
[Agent N results]

Verify:
- Consistent formatting
- No missing information
- No obvious errors
- No conflicting data

Flag any issues for follow-up.`,
  subagent_type: "general-purpose",
  model: "haiku"  // Fast spotcheck
})

Common Mistakes to Avoid

❌ WRONG: Sequential execution

await Task({ ... }); // Agent 1 (blocks)
await Task({ ... }); // Agent 2 (waits for 1)
await Task({ ... }); // Agent 3 (waits for 2)
// Takes 3x as long!

✅ RIGHT: Parallel execution

// Send ONE message with multiple Task calls:
Task({ ... })  // Agent 1
Task({ ... })  // Agent 2
Task({ ... })  // Agent 3
// All run simultaneously

❌ WRONG: Using the deprecated Intern agent type

// Intern type has been removed from the system
Task({
  description: "Research X",
  prompt: "Research X and report findings",
  subagent_type: "Intern",  // DOES NOT EXIST — removed from system
  model: "haiku"
})

✅ RIGHT: Use general-purpose agents or agents composed via ComposeAgent

// For simple parallel work, use general-purpose type
Task({
  description: "Research X",
  prompt: "Research X and report findings",
  subagent_type: "general-purpose",
  model: "haiku"
})
// For specialized parallel work, compose a custom agent first via ComposeAgent
// or use a specialized type like "Engineer", "Architect", etc.

❌ WRONG: Skipping spotcheck

// Launch agents, get results, done
// No validation = potential inconsistencies

✅ RIGHT: Always spotcheck

// Launch agents
// Get results
// Spotcheck for consistency
// THEN report as complete

❌ WRONG: Using opus for simple parallel tasks

// Each agent uses opus = slow + expensive
Task({ ..., model: "opus" })
Task({ ..., model: "opus" })
Task({ ..., model: "opus" })

✅ RIGHT: Use haiku for grunt work

// 10-20x faster, sufficient for simple tasks
Task({ ..., model: "haiku" })
Task({ ..., model: "haiku" })
Task({ ..., model: "haiku" })

Voice Output

Voice Output

For grunt work, voice output is optional. If enabled, all parallel agents use the default voice configuration.

This is intentional - for parallel grunt work, we prioritize speed over personality diversity. For unique voices and identities, use the CreateCustomAgent workflow instead.

When to Use Custom Agents Instead

Use CreateCustomAgent workflow when:

• User says "custom agents" (the key trigger)
• You need distinct personalities/perspectives
• Voice and color diversity matters
• Different analytical approaches required
• Each agent brings unique expertise

Use SpawnParallelAgents workflow when:

• Simple parallel processing (no "custom" keyword)
• Same task, different inputs
• Speed matters more than personality
• Identity diversity not needed

Related Workflows

• CreateCustomAgent - For agents with unique personalities, voices, and colors
• ListTraits - Show available traits for custom agents

References

• Agent personalities: ~/.config/openpai/skills/Agents/AgentPersonalities.md