1.6 Task Decomposition Strategies

# Task: "Review entire codebase for security issues"
subtasks = [
    "Review authentication code in src/auth/",
    "Review API endpoints in src/routes/",
    "Review database queries in src/models/",
    "Review file upload handling in src/uploads/",
]

# Execute in parallel — independent scopes
results = await parallel([
    lambda: agent(task, {label: f"reviewer-{i}"})
    for i, task in enumerate(subtasks)
])

# Task: "Write a technical blog post about MCP"
# Stage 1: Research
research = await agent("Research MCP protocol - features, use cases, examples")

# Stage 2: Outline
outline = await agent(f"Create blog post outline based on: {research}")

# Stage 3: Draft
draft = await agent(f"Write full draft following this outline: {outline}")

# Stage 4: Edit
final = await agent(f"Edit and polish this draft: {draft}")

DECOMPOSE_SCHEMA = {
    "type": "object",
    "properties": {
        "subtasks": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "description": {"type": "string"},
                    "depends_on": {"type": "array", "items": {"type": "integer"}},
                    "complexity": {"type": "string", "enum": ["simple", "complex"]}
                }
            }
        }
    }
}

# Let the orchestrator decompose
plan = await agent(f"""
Decompose this task into subtasks:
Task: {complex_task}

Rules:
- Each subtask should be completable by one agent
- Mark dependencies between subtasks
- Mark complexity (simple = one agent, complex = needs further decomposition)
""", {schema: DECOMPOSE_SCHEMA})

# Execute — further decompose complex ones
for subtask in topological_sort(plan.subtasks):
    if subtask.complexity == "complex":
        result = await decompose_and_execute(subtask)
    else:
        result = await agent(subtask.description)

# Task dependencies
#   A (research) → C (design)
#   B (analyze)  → C (design)
#   C (design)   → D (implement)
#   C (design)   → E (test plan)

# Round 1: A and B are independent → parallel
a, b = await parallel([
    lambda: agent("Research requirements"),
    lambda: agent("Analyze existing system")
])

# Round 2: C depends on A and B
c = await agent(f"Design solution based on: {a} and {b}")

# Round 3: D and E depend on C but not each other → parallel
d, e = await parallel([
    lambda: agent(f"Implement design: {c}"),
    lambda: agent(f"Write test plan for: {c}")
])