# DEEP-RESEARCH: INFINITE PARALLEL MULTI-AGENT RESEARCH COMMAND

**Think deeply about this infinite research task. You are about to orchestrate a sophisticated parallel multi-agent research system where each agent explores unique, non-overlapping angles of any topic.**

## ARGUMENTS PARSING
Parse the following arguments from "$ARGUMENTS":
1. `topic` - The research topic to investigate
2. `num_agents` - Number of parallel research agents (3-10, default 5)
3. `max_iterations` - Number of iterations (1-N or "infinite", default "infinite")

## PHASE 1: RESEARCH SPECIFICATION ANALYSIS

**Deep Understanding of Research Requirements:**
- Topic: Extract and understand the core research topic
- Scope: Determine breadth and depth requirements
- Angles: Identify N distinct research perspectives where N = num_agents
- Evolution: Plan how research should deepen with each iteration

**Agent Specialization Matrix:**
Based on num_agents, assign UNIQUE, NON-OVERLAPPING research angles:

```
For num_agents = 5 (default):
- ALPHA: Mainstream/Academic/Authoritative sources
- BETA: Contrarian/Critical/Alternative perspectives  
- GAMMA: Technical/Implementation/Practical details
- DELTA: Historical/Evolutionary/Origins context
- EPSILON: Future/Predictions/Emerging trends

For num_agents = 3 (minimum):
- ALPHA: Current state & mainstream understanding
- BETA: Problems/Criticisms/Alternatives
- GAMMA: Future implications & applications

For num_agents = 10 (maximum):
Add: ZETA (Cross-domain), ETA (Ethics/Risk), THETA (Global), IOTA (Economic), KAPPA (Social)
```

## PHASE 2: OUTPUT DIRECTORY INITIALIZATION

**Create Research Structure:**
```bash
/deep-research/{sanitized_topic}/
├── .session                      # Agent coordination & search tracking
├── overview.md                   # Master research document
├── synthesis-{timestamp}.md      # Periodic synthesis (every 3 iterations)
├── agent-alpha-research.md       # Individual agent findings
├── agent-beta-research.md
├── agent-gamma-research.md
├── agent-delta-research.md
├── agent-epsilon-research.md
└── convergence-map.json         # Tracks emerging themes across agents
```

**Initialize .session file:**
```json
{
  "topic": "{topic}",
  "created": "{timestamp}",
  "iteration": 0,
  "agents": {
    "alpha": {
      "role": "Mainstream Explorer",
      "searched_queries": [],
      "fetched_urls": [],
      "key_findings": [],
      "avoided_terms": []
    },
    // ... other agents
  },
  "global_search_history": [],
  "unique_domains_explored": [],
  "convergence_topics": []
}
```

## PHASE 3: PARALLEL AGENT COORDINATION STRATEGY

**CRITICAL COORDINATION RULES:**
1. **Zero Overlap Principle**: Each agent MUST search completely different queries
2. **Domain Diversity**: Agents should explore different types of sources
3. **Perspective Isolation**: Each agent maintains a unique analytical lens
4. **Cross-Pollination**: Agents read others' findings but explore orthogonal angles

**Collision Avoidance Protocol:**
```python
def ensure_unique_search(agent_id, proposed_query):
    # Check against ALL previous searches by ALL agents
    # Use semantic similarity < 30% threshold
    # If collision detected, modify query with agent-specific terms
    # Maintain global_search_history in .session
```

## PHASE 4: PARALLEL AGENT DEPLOYMENT

**For EACH iteration, deploy ALL agents SIMULTANEOUSLY:**

```
=== ITERATION {N}: LAUNCHING {num_agents} PARALLEL RESEARCH AGENTS ===

# PREPARE AGENT CONTEXTS
for each agent in [alpha, beta, gamma, delta, epsilon...]:
    context = {
        "iteration": N,
        "session_snapshot": read_session(),
        "other_agents_searches": get_all_other_searches(agent),
        "unique_angle": AGENT_STRATEGIES[agent],
        "avoidance_list": compile_global_search_list()
    }

# DEPLOY ALL AGENTS IN PARALLEL
parallel_tasks = []

for agent_id in active_agents:
    task = create_research_task(agent_id, context)
    parallel_tasks.append(deploy_sub_agent(task))

# PARALLEL EXECUTION
execute_all_tasks_simultaneously(parallel_tasks)
wait_for_all_completions()
update_global_session()
```

**INDIVIDUAL AGENT TASK TEMPLATE:**
```
TASK: Deep Research Agent {AGENT_ID} - {SPECIALIZATION} (Iteration {N})

You are Research Agent {AGENT_ID}, specialized in: {UNIQUE_FOCUS}

CRITICAL MISSION: Find information that NO OTHER AGENT will find.

COORDINATION DATA:
- Session file: /deep-research/{topic}/.session
- Other agents' searches: [COMPLETE LIST - YOU MUST AVOID ALL]
- Your previous searches: [LIST]
- Forbidden overlap threshold: 30% similarity

YOUR UNIQUE RESEARCH PROTOCOL:

1. DIVERGENT SEARCH STRATEGY:
   - Read .session to see ALL previous searches
   - Generate 5 COMPLETELY UNIQUE search queries
   - Each query MUST be < 30% similar to any existing
   - Use your specialization lens: {SPECIALIZATION_KEYWORDS}
   - Avoid domains already heavily explored

2. SEARCH EXECUTION:
   For each unique query:
   a) web_search with your specialized query
   b) Analyze results for YOUR SPECIFIC ANGLE
   c) web_fetch 2-3 most promising URLs
   d) Extract findings relevant to YOUR PERSPECTIVE

3. UNIQUE DISCOVERY DOCUMENTATION:
   Write to: /deep-research/{topic}/agent-{agent_id}-research.md
   
   ## Iteration {N} - Agent {AGENT_ID} Findings
   **Specialization:** {FOCUS}
   **Unique Queries Used:**
   1. "{query1}" - Why unique: {reasoning}
   2. "{query2}" - Why unique: {reasoning}
   
   ### Exclusive Discoveries
   [Findings that ONLY your specialization would uncover]
   
   ### Contrasting Perspectives
   [How your findings challenge/complement other agents]
   
   ### Unexplored Territories
   [Areas within your domain still requiring investigation]

4. SESSION UPDATE:
   - Add all queries to .session
   - Mark explored domains
   - Flag breakthrough findings
   - Update convergence topics if patterns emerge

REMEMBER: Your value is in finding what others DON'T find!
```

## PHASE 5: INFINITE MODE ORCHESTRATION

**Wave-Based Parallel Execution:**

```python
iteration = 1
while should_continue(iteration, max_iterations):
    
    # WAVE PLANNING
    print(f"\n{'='*60}")
    print(f"ITERATION {iteration}: Deploying {num_agents} Parallel Research Agents")
    print(f"{'='*60}\n")
    
    # PARALLEL DEPLOYMENT
    agent_tasks = []
    for agent_id in active_agents:
        # Each agent gets fresh context with collision avoidance
        task = create_unique_research_task(agent_id, iteration)
        agent_tasks.append((agent_id, task))
    
    # SIMULTANEOUS EXECUTION
    print("🚀 LAUNCHING ALL AGENTS SIMULTANEOUSLY...")
    for agent_id, task in agent_tasks:
        print(f"   ⚡ Agent {agent_id.upper()} - {STRATEGIES[agent_id]['name']}")
        deploy_task(task)
    
    # COORDINATION BARRIER
    print("\n⏳ Waiting for all agents to complete...")
    wait_for_all_agents_completion()
    
    # CONVERGENCE ANALYSIS
    analyze_convergence_patterns()
    update_global_session()
    
    # SYNTHESIS (Every 3 iterations)
    if iteration % 3 == 0:
        deploy_synthesis_agent(iteration)
    
    # CONTEXT MONITORING
    if get_context_usage() > 0.8:
        print("\n📊 Approaching context limit - Final synthesis...")
        deploy_final_synthesis()
        break
    
    # STAGNATION DETECTION
    if detect_research_stagnation():
        print("\n🔄 Injecting creativity boost...")
        inject_wildcard_perspectives()
    
    iteration += 1
```

**Progressive Sophistication Strategy:**
- **Iterations 1-3**: Broad exploration, establishing baselines
- **Iterations 4-6**: Deep dives into promising areas
- **Iterations 7-9**: Cross-domain synthesis and pattern recognition
- **Iterations 10+**: Revolutionary connections and breakthrough insights

## PHASE 6: EXECUTION PRINCIPLES

**Quality Through Diversity:**
- Each parallel agent MUST maintain unique perspective
- Collision detection ensures zero overlap in searches
- Domain diversity prevents echo chamber effects
- Cross-pollination happens through reading, not searching

**Coordination Excellence:**
- All agents launch truly simultaneously
- Session file provides real-time coordination
- Global search history prevents any duplication
- Convergence tracking identifies emerging themes

**Infinite Scalability:**
- Wave-based execution manages context efficiently
- Progressive summarization maintains continuity
- Fresh agent instances prevent context accumulation
- Graceful conclusion when approaching limits

## ULTRA-THINKING DIRECTIVE

Before beginning execution, engage in extended analysis of:

**Research Topology:**
- How to partition the topic into N non-overlapping domains
- Optimal search query generation for maximum coverage
- Semantic distance calculations for collision avoidance
- Cross-domain insight synthesis strategies

**Parallel Orchestration:**
- Simultaneous agent deployment mechanisms
- Real-time coordination through session management
- Conflict resolution for file access
- Quality assurance across parallel streams

**Infinite Optimization:**
- Context usage prediction models
- Stagnation detection algorithms
- Creativity injection techniques
- Graceful termination strategies

**Begin with deep contemplation of the research topology, then execute the parallel multi-agent research system with perfect coordination and zero overlap.**