Agent architectures: router, plan-and-execute, supervisor, handoffs and human gates

Module 07 showed the agent loop and five simple workflow patterns. Production agents are usually built from a handful of larger shapes: a router that sends each request to a specialist, a planner that writes the steps before acting, a supervisor that delegates to sub-agents, handoffs that pass the conversation between agents, and human gates before anything risky. This module explains each one, when it fits, what it costs, and how the main frameworks implement it, with a demo you can run and real systems that chose each shape.

1. The idea

They combine. LinkedIn's Hiring Assistant is a supervisor that plans and executes, with humans approving the decisions recruiters are accountable for (Case C13). Start with one agent and add structure only where a measured problem needs it.

2. How it works

One support system, four requests. The router picks a specialist; the billing agent plans, executes, replans when the policy check fails, and pauses at a human gate for a large refund.

Supervisor or handoffs?

3. Try it yourself

Choose an architecture

Where does the human gate go?

For each action an agent can take, choose: let it run, gate it behind approval, or never let the agent do it.

4. Why it matters at work

When to use which, from real systems

For both decisions together, rigor and architecture, see Module 20a: When to use which.

The support system in code

A router, a plan-execute-replan loop and an approval gate, in about 50 lines. The refund over $100 pauses for a human; the 45-day-old order fails the policy check and the plan is rewritten to offer store credit. The program was run in all three languages; each prints the output below it.

ORDERS = {"81": (40, 10), "92": (250, 5), "77": (60, 45)}   # order id -> (amount in dollars, days since purchase)
APPROVAL_LIMIT = 100        # refunds above this need a human
REFUND_WINDOW = 30          # days


def route(message):
    """Router: send each request to one specialist. A small, cheap model does this in practice; keywords stand in here."""
    text = message.lower()
    if "refund" in text or "charge" in text:
        return "billing"
    if "crash" in text or "error" in text:
        return "tech"
    return "general"


def plan(order_id):
    """Planner: write the whole plan up front, before acting."""
    return ["look up order", "check refund policy", "issue refund", "email customer"]


def execute(order_id, approve):
    amount, days = ORDERS[order_id]
    steps, log = plan(order_id), []
    while steps:
        step = steps.pop(0)
        if step == "check refund policy" and days > REFUND_WINDOW:
            log.append(f"{step}: {days} days, outside the {REFUND_WINDOW}-day window -> replan")
            steps = ["offer store credit", "email customer"]          # replan from what was observed
            continue
        if step == "issue refund" and amount > APPROVAL_LIMIT:
            decision = approve(order_id, amount)                       # human gate: execution pauses here
            log.append(f"{step}: ${amount} needs approval -> {decision}")
            if decision != "approved":
                steps = ["email customer"]
            continue
        log.append(step)
    return log


def human(order_id, amount):
    return "approved"         # in a real system the run waits, saved, until a person decides


requests = ["The app crashes when I log in", "Please refund order 81", "Please refund order 92", "Please refund order 77"]
for message in requests:
    agent = route(message)
    print(f'"{message}" -> {agent} agent')
    if agent == "billing":
        for line in execute(message.split()[-1], human):
            print("   ", line)

const ORDERS: Record<string, [number, number]> = { "81": [40, 10], "92": [250, 5], "77": [60, 45] }; // order id -> [amount in dollars, days since purchase]
const APPROVAL_LIMIT = 100; // refunds above this need a human
const REFUND_WINDOW = 30; // days

// Router: send each request to one specialist. A small, cheap model does this in practice; keywords stand in here.
function route(message: string): string {
  const text = message.toLowerCase();
  if (text.includes("refund") || text.includes("charge")) return "billing";
  if (text.includes("crash") || text.includes("error")) return "tech";
  return "general";
}

// Planner: write the whole plan up front, before acting.
function plan(orderId: string): string[] {
  return ["look up order", "check refund policy", "issue refund", "email customer"];
}

function execute(orderId: string, approve: (id: string, amount: number) => string): string[] {
  const [amount, days] = ORDERS[orderId];
  let steps = plan(orderId);
  const log: string[] = [];
  while (steps.length) {
    const step = steps.shift()!;
    if (step === "check refund policy" && days > REFUND_WINDOW) {
      log.push(`${step}: ${days} days, outside the ${REFUND_WINDOW}-day window -> replan`);
      steps = ["offer store credit", "email customer"]; // replan from what was observed
      continue;
    }
    if (step === "issue refund" && amount > APPROVAL_LIMIT) {
      const decision = approve(orderId, amount); // human gate: execution pauses here
      log.push(`${step}: $${amount} needs approval -> ${decision}`);
      if (decision !== "approved") steps = ["email customer"];
      continue;
    }
    log.push(step);
  }
  return log;
}

const human = (orderId: string, amount: number) => "approved"; // in a real system the run waits, saved, until a person decides

const requests = ["The app crashes when I log in", "Please refund order 81", "Please refund order 92", "Please refund order 77"];
for (const message of requests) {
  const agent = route(message);
  console.log(`"${message}" -> ${agent} agent`);
  if (agent === "billing") {
    const words = message.split(" ");
    for (const line of execute(words[words.length - 1], human)) console.log("   ", line);
  }
}

import java.util.*;
import java.util.function.BiFunction;

public class Main {
    static final Map<String, int[]> ORDERS = Map.of("81", new int[] {40, 10}, "92", new int[] {250, 5}, "77", new int[] {60, 45}); // order id -> {amount in dollars, days since purchase}
    static final int APPROVAL_LIMIT = 100; // refunds above this need a human
    static final int REFUND_WINDOW = 30;   // days

    // Router: send each request to one specialist. A small, cheap model does this in practice; keywords stand in here.
    static String route(String message) {
        String text = message.toLowerCase();
        if (text.contains("refund") || text.contains("charge")) return "billing";
        if (text.contains("crash") || text.contains("error")) return "tech";
        return "general";
    }

    // Planner: write the whole plan up front, before acting.
    static Deque<String> plan(String orderId) {
        return new ArrayDeque<>(List.of("look up order", "check refund policy", "issue refund", "email customer"));
    }

    static List<String> execute(String orderId, BiFunction<String, Integer, String> approve) {
        int amount = ORDERS.get(orderId)[0], days = ORDERS.get(orderId)[1];
        Deque<String> steps = plan(orderId);
        List<String> log = new ArrayList<>();
        while (!steps.isEmpty()) {
            String step = steps.poll();
            if (step.equals("check refund policy") && days > REFUND_WINDOW) {
                log.add(step + ": " + days + " days, outside the " + REFUND_WINDOW + "-day window -> replan");
                steps = new ArrayDeque<>(List.of("offer store credit", "email customer")); // replan from what was observed
                continue;
            }
            if (step.equals("issue refund") && amount > APPROVAL_LIMIT) {
                String decision = approve.apply(orderId, amount); // human gate: execution pauses here
                log.add(step + ": $" + amount + " needs approval -> " + decision);
                if (!decision.equals("approved")) steps = new ArrayDeque<>(List.of("email customer"));
                continue;
            }
            log.add(step);
        }
        return log;
    }

    public static void main(String[] args) {
        BiFunction<String, Integer, String> human = (id, amount) -> "approved"; // in a real system the run waits, saved, until a person decides
        for (String message : List.of("The app crashes when I log in", "Please refund order 81", "Please refund order 92", "Please refund order 77")) {
            String agent = route(message);
            System.out.println("\"" + message + "\" -> " + agent + " agent");
            if (agent.equals("billing")) {
                String[] words = message.split(" ");
                for (String line : execute(words[words.length - 1], human)) System.out.println("    " + line);
            }
        }
    }
}

"The app crashes when I log in" -> tech agent
"Please refund order 81" -> billing agent
    look up order
    check refund policy
    issue refund
    email customer
"Please refund order 92" -> billing agent
    look up order
    check refund policy
    issue refund: $250 needs approval -> approved
    email customer
"Please refund order 77" -> billing agent
    look up order
    check refund policy: 45 days, outside the 30-day window -> replan
    offer store credit
    email customer

In a real system the gate saves the run's state and stops; a person approves in a dashboard or chat, and the run resumes from the saved point, possibly days later. That's what LangGraph's interrupt() and the workflow checkpointing in Microsoft Agent Framework provide.

5. In the frameworks

Frameworks rename things often; the shapes stay the same. Checked 4 November 2026.

6. Remember it

7. Common mistakes

8. Hands-on lab (roadmap week 7)

1. Baseline: build a single agent with three tools for a small support desk. Record success on 20 test requests.
2. Router: add a router in front with two specialists. Did accuracy or cost change?
3. Plan-and-execute: for a five-step task, have the agent write the plan first and replan when a step fails. Compare with the plain loop.
4. Gate: put an approval gate inside the refund tool (not the prompt). Try to talk the agent past it.
5. Write the rule: one paragraph for your team on which architecture to start with, and what evidence justifies adding the next.

9. Self-check quiz

10. Go deeper