from concurrent.futures import ascompleted

import asyncio

agents = {
    "securityreviewer": AgentDefinition(...),
    "performanceanalyst": AgentDefinition(...),

    "testvalidator": AgentDefinition(...)
}

All agents work on same codebase in parallel

async for message in query(
    prompt="Audit auth.ts: review security, analyze performance, validate tests",
    options={"agents": agents}
):
    # Claude decides to use all 3 agents
    # Each runs in parallel on their task
    if isinstance(message, ResultMessage):
        print(f"Security issues: {message.result}")

async for message in query(

    prompt="""Review the new authentication module:
    1. Security reviewer: audit for vulnerabilities
    2. Performance reviewer: check for bottlenecks
    3. Style reviewer: verify it matches code style
    4. Test reviewer: confirm tests are comprehensive
    """,
    options={
        "agents": {
            "securityreviewer": securityagent,
            "performancereviewer": perfagent,
            "stylereviewer": styleagent,
            "testreviewer": testagent
        }
    }
):
    if isinstance(message, ResultMessage):
        print(message.result)
        # Output might be:
        # Security: Found 2 issues with password hashing
        # Performance: No bottlenecks found
        # Style: Follows conventions
        # Tests: 95% coverage, good!

{

  "env": {
    "CLAUDECODEEXPERIMENTALAGENTTEAMS": "1"
  }
}

$ claude "Create an agent team to refactor the database layer. 

          Spawn an architect to design changes, 
          an implementer to code them, 
          and a reviewer to validate."

Lead: "We need to migrate the payment processor from Stripe to PayPal"


Creates team with tasks:
  □ Research PayPal API and authentication
  □ Design new payment flow
  □ Implement new PayPal integration
  □ Migrate existing payment records
  □ Write integration tests
  □ Update documentation

Team members:
  Architect: Takes "Design new payment flow"
  Developer: Takes "Implement new PayPal integration"
  QA: Takes "Write integration tests"
  ...they work in parallel...

Results come back to Lead

Developer: "I'm implementing the PayPal integration. 

           @Architect, can you clarify the retry logic for failed charges?"

Architect: "@Developer, for failed charges:
           1. Retry up to 3 times with exponential backoff
           2. Log each failure
           3. Alert admin after 3 failures"

Developer: "Got it, implementing now..."

Main agent:

  "I need to solve this problem"
  
  Forks:
    ├─ Agent A: "Try approach 1"
    ├─ Agent B: "Try approach 2"
    └─ Agent C: "Try approach 3"
  
  Joins:
    Approach 1 result
    Approach 2 result  
    Approach 3 result
    
    Main: "Approach 2 is best because..."

Input → Agent A → Agent B → Agent C → Output


Example:
  Raw log data → Parser agent → Analyzer agent → Report agent → Summary

Data chunks:

  [Chunk 1] → Agent A (parallel)
  [Chunk 2] → Agent B (parallel)
  [Chunk 3] → Agent C (parallel)
  
Results → Aggregator agent → Final summary

Lead agent

├─ Team A (3 agents): Works on Feature A
├─ Team B (3 agents): Works on Feature B
└─ Team C (2 agents): Works on Integration

Lead coordinates across teams

Terminal 1: Work on feature-a

$ cd cc-agents
$ git worktree add ../cc-agents-feature-a feature-a
$ cd ../cc-agents-feature-a
$ claude "Implement user authentication"

Terminal 2: Work on feature-b (different directory)

$ cd cc-agents
$ git worktree add ../cc-agents-feature-b feature-b
$ cd ../cc-agents-feature-b
$ claude "Implement payment processing"

Scenario: Refactor authentication from JWT to OAuth2


async for message in query(
    prompt="""Lead a multi-agent refactoring:
    
    1. Researcher: Investigate current JWT implementation, 
       identify all files that use it
    
    2. Designer: Design OAuth2 integration, write migration plan
    
    3. Implementer: Code the OAuth2 provider integration
    
    4. Migrator: Move existing JWT auth to OAuth2
    
    5. Tester: Write integration tests for new auth
    
    6. Reviewer: Verify no regressions, performance is good
    
    Coordinate to complete all work in parallel where possible.
    """,
    options={
        "agents": {
            "researcher": researcheragent,

            "designer": designeragent,
            "implementer": implementeragent,

            "migrator": migratoragent,
            "tester": testeragent,

            "reviewer": revieweragent
        }
    }
):
    if isinstance(message, ResultMessage):
        print(message.result)