Pattern-029: Multi-Agent Coordination

class AgentRole(Enum):
    ARCHITECT = "architect"        # Strategic planning, gameplans
    BACKEND = "code"               # Services, domain logic, investigations
    FRONTEND = "cursor"            # UI, templates, user experience
    ANALYST = "analyst"            # Data analysis, pattern detection
    DOCUMENTER = "documenter"      # Documentation, ADRs, patterns

class MultiAgentOrchestrator:
    """
    Coordinates multiple specialized agents for complex tasks.
    Based on May 27 vision, implemented via scripts.
    """

    def deploy_agents(self, task: Task) -> DeploymentPlan:
        """
        Determine which agents needed and their coordination.
        """
        if task.requires_investigation:
            agents = [AgentRole.BACKEND]  # Code for broad investigation

        if task.requires_ui_changes:
            agents.append(AgentRole.FRONTEND)  # Cursor for UI

        if task.requires_architecture:
            agents.insert(0, AgentRole.ARCHITECT)  # Architect plans first

        return self.create_deployment_plan(agents, task)

    def create_deployment_plan(self, agents: List[AgentRole], task: Task):
        """
        Define coordination points and handoffs.
        """
        plan = DeploymentPlan()

        # Phase 0: Always investigation first
        plan.add_phase("investigation", agents[0],
                      "Verify infrastructure, check existing patterns")

        # Parallel execution where possible
        if len(agents) > 1 and task.allows_parallel:
            plan.add_parallel_phase("implementation", agents,
                                  "Cross-validate every 30 minutes")

        # Sequential handoffs where needed
        else:
            for i, agent in enumerate(agents):
                plan.add_sequential_phase(f"phase_{i}", agent,
                                        "Complete and hand off to next")

        return plan

# Agents validate each other's work
class CrossValidation:
    """
    Pattern for agents to verify each other's outputs.
    """

    def validate_backend_changes(self, changes: CodeChanges) -> ValidationResult:
        """Cursor validates Code's backend changes don't break UI"""
        pass

    def validate_ui_changes(self, changes: UIChanges) -> ValidationResult:
        """Code validates Cursor's UI changes follow patterns"""
        pass

    def consensus_required(self) -> bool:
        """Both agents must agree on critical changes"""
        return self.change_severity > Severity.MEDIUM