Multi-Agent and Protocol Terms: Orchestration, Hierarchical Agents, Router, MCP, A2A

The final cluster moves beyond a single agent's own reasoning to how MULTIPLE agents — and the systems they connect to — are coordinated.

Orchestration is the coordination and control of multiple agents working together to achieve complex tasks — the umbrella term for 'making a team of agents function as one coherent system.' A Multi-agent system is the resulting group of agents collaborating to accomplish a final goal — orchestration is the activity; a multi-agent system is the thing being orchestrated.

One common way to organize that collaboration is Hierarchical Agents — a multi-level agent structure where a supervisor agent delegates tasks to sub-agents, rather than every agent coordinating with every other agent as equals. Within any multi-agent system, a Router is a mechanism that directs tasks to the most appropriate agent or tool — the piece of logic that decides WHICH agent (or tool) should handle a given piece of work.

A related but distinct concern is when a human needs to be in that loop: Human-in-the-loop is a setup where humans intervene or guide the agent's decision-making process — this can apply to a single agent or an entire multi-agent system, wherever a checkpoint for human judgment is inserted.

The last two terms are the standardized protocols that make multi-agent (and agent-to-tool) coordination possible without custom, one-off integration code for every pairing. MCP (Model Context Protocol) is a standardized way for agents to connect to external tools, APIs, and data sources — covered in depth elsewhere in this curriculum via its 6 core primitives. A2A (Agent-to-Agent) is a protocol enabling agents to communicate and exchange data directly with OTHER agents — the direct counterpart to MCP, but for agent-to-agent rather than agent-to-tool communication.

Together, these 7 terms describe the full path from a single orchestrated team (Orchestration, Multi-agent system, Hierarchical Agents, Router, Human-in-the-loop) to the standardized protocols (MCP, A2A) that let those teams — and the tools they use — talk to each other without custom wiring for every new connection.

class Orchestrator:
    """Illustrates Orchestration of a Multi-agent system using a
    Router, Hierarchical delegation, and a Human-in-the-loop check."""
    def __init__(self, sub_agents: dict, requires_human_approval_for: set[str]):
        self.sub_agents = sub_agents   # e.g. {"finance": FinAgent(), "legal": LawAgent()}
        self.requires_human_approval_for = requires_human_approval_for

    def route(self, task: str) -> str:
        """Router: decide which sub-agent should handle this task."""
        if "invoice" in task or "budget" in task:
            return "finance"
        if "contract" in task or "compliance" in task:
            return "legal"
        return "general"

    def delegate(self, task: str) -> str:
        """Hierarchical Agents: this supervisor delegates to sub-agents
        rather than handling every task itself."""
        target = self.route(task)
        if target in self.requires_human_approval_for:
            return f"[Human-in-the-loop] Awaiting approval before routing '{task}' to {target}"
        # In practice, sub_agents[target] might itself connect to tools via
        # MCP, or to OTHER agents via A2A — both standardized protocols
        return self.sub_agents[target].handle(task)