Day 24: Multi-Agent Orchestration — Supervisor, Worker and Evaluator Patterns

As a workflow grows, handing one agent every tool and a long list of responsibilities makes it worse. The prompt gets crowded, the model picks the wrong tool and the context window fills up. The fix is the one human organisations use: divide the work among specialists who collaborate.

In plain terms: A hospital does not give one doctor every job. A coordinator sends each patient to the right specialist, and a second doctor reviews the plan before treatment begins.

Three patterns

• Worker (specialisation). A small agent with a narrow scope and its own limited tools. A log-parser worker can only read logs. A database worker has a read-only SQL connection. A tight scope improves accuracy and limits damage.
• Supervisor (routing and delegation). The coordinator. It reads a high-level request, splits it into sub-tasks, hands them to the right workers and combines the results into one answer.
• Evaluator (validation and guardrails). An independent agent that reviews worker output against policy, accuracy rules and business logic before anything is committed or shown to the user. Keeping it separate matters, because a worker checking its own work tends to approve it.

State and orchestration

Coordinating several agents calls for a real state machine. Frameworks such as LangGraph (Python) and Mastra (TypeScript) model the system as a directed graph.

• Nodes are agents, tool executions or human-approval checkpoints.
• Edges are routing rules based on what earlier nodes returned.
• Durable state records progress after each step (a checkpoint), so if a pod crashes mid-run the workflow resumes from the last confirmed node instead of starting over.

Here is the pattern without any framework, so the idea is clear. The ask_* functions stand in for model calls with different system prompts and tools, and a framework adds the graph, retries and persistent checkpoints for you.

def run_workflow(request: str, state: dict) -> str:
    # Supervisor splits the request into sub-tasks (cached in state so a restart skips done work)
    state.setdefault("plan", ask_supervisor(request))            # e.g. ["parse_logs", "check_db"]

    for task in state["plan"]:
        if task in state.setdefault("results", {}):
            continue                                              # resume: this step already finished
        worker = WORKERS[task]                                    # each worker has its own narrow tools
        state["results"][task] = worker(request)
        save_checkpoint(state)                                    # durable state after every step

    draft = ask_supervisor_combine(state["results"])
    verdict = ask_evaluator(draft, policy=POLICY)                 # independent quality gate
    if verdict != "approved":
        return "Held for human review"                            # an approval node in a real graph
    return draft

Structuring agents as modular teams mirrors high-performing engineering organisations: clear roles, small scopes and a reviewer, which is what makes complex tasks dependable.

Coming Up Next

Day 25: Automated CI/CD: automating the software lifecycle for AI models.

#MultiAgentSystems #LangGraph #SystemDesign #AgenticAI #SoftwareEngineering