A Committee of Specialists

# labs/multi_agent.py
from typing import Callable

def home_control_agent(text: str) -> str:
    return f"[HOME] Executing home command for: '{text}'"

def knowledge_agent(text: str) -> str:
    return f"[KNOWLEDGE] Looking up: '{text}'"

AGENT_REGISTRY: dict[str, Callable[[str], str]] = {
    "home_control": home_control_agent,
    "knowledge": knowledge_agent,
}

print(AGENT_REGISTRY["home_control"]("Turn off the lights."))
print(AGENT_REGISTRY["knowledge"]("What is the speed of light?"))

$ uv run python labs/multi_agent.py
[HOME] Executing home command for: 'Turn off the lights.'
[KNOWLEDGE] Looking up: 'What is the speed of light?'

If this file feels familiar, it should: functions filed in a dict by string key is chapter 17's action registry wearing a new hat. The caller never names an agent in code; it asks the registry for whatever is filed under an intent string. Adding a fifth agent later means adding one key, not editing a branch. The dict stores the function objects themselves, a fact you have been using since chapter 2, and it is about to carry the whole design.

INTENT_KEYWORDS: dict[str, list[str]] = {
    "home_control": ["lights", "timer", "switch", "turn on", "turn off", "thermostat"],
    "knowledge": ["what is", "who is", "how does", "explain", "define", "when did"],
    "creative": ["write", "poem", "story", "joke", "haiku", "creative"],
}

def classify_intent(text: str) -> str:
    lower = text.lower()
    for intent, keywords in INTENT_KEYWORDS.items():
        if any(kw in lower for kw in keywords):
            return intent
    return "fallback"

for q in [
    "Turn off the lights in the kitchen.",
    "What is the speed of light?",
    "Write me a haiku about robots.",
    "Do something random.",
]:
    print(f"{classify_intent(q):<13} <- {q}")

$ uv run python labs/multi_agent.py
home_control  <- Turn off the lights in the kitchen.
knowledge     <- What is the speed of light?
creative      <- Write me a haiku about robots.
fallback      <- Do something random.

Classification answers "what kind of request is this?", which is a fact about the input, so it returns an intent name and not an agent. Keeping the question separate from the dispatch means you can swap keyword matching for a smarter classifier later without touching the registry. The any() short-circuits at the first keyword hit, so even long lists stay cheap, and the unmatched case is an explicit "fallback" string instead of a crash. That last choice is the hinge of the failure box.

def creative_agent(text: str) -> str:
    return f"[CREATIVE] Generating content for: '{text}'"

def fallback_agent(text: str) -> str:
    return f"[FALLBACK] I'm not sure how to handle: '{text}'"

AGENT_REGISTRY["creative"] = creative_agent
AGENT_REGISTRY["fallback"] = fallback_agent

def route(text: str) -> str:
    intent = classify_intent(text)
    agent_fn = AGENT_REGISTRY[intent]
    print(f"  [ROUTER] Intent: '{intent}'")
    return agent_fn(text)

if __name__ == "__main__":
    for q in [
        "Turn off the lights in the kitchen.",
        "Write me a haiku about robots.",
        "Do something random.",
    ]:
        print(route(q), "\n")

$ uv run python labs/multi_agent.py
  [ROUTER] Intent: 'home_control'
[HOME] Executing home command for: 'Turn off the lights in the kitchen.'

  [ROUTER] Intent: 'creative'
[CREATIVE] Generating content for: 'Write me a haiku about robots.'

  [ROUTER] Intent: 'fallback'
[FALLBACK] I'm not sure how to handle: 'Do something random.'

The router is four lines: classify, look up, log, call. The log line is not decoration; it is the router answering "why did you do that?" before anyone asks, and when a request lands on the wrong specialist, that one line tells you whether to blame the classifier or the agent. Note that fallback_agent is registered exactly like its more talented colleagues. "I don't know" is a real answer, and giving it a real seat at the table is what keeps the router total: every string the classifier can return has a function waiting for it.