M06 — Multi-Agent Systems

// multiagent_raw.mjs — specialists are TOOLS. This is the M03 loop, unchanged.
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const MODEL = "claude-sonnet-5";

async function specialist(system, msg) {            // a specialist = its own Claude call
  const r = await client.messages.create({ model: MODEL, max_tokens: 512, system,
    messages: [{ role: "user", content: msg }] });
  return r.content.filter(b => b.type === "text").map(b => b.text).join("");
}

const DISPATCH = {
  route_to_orders:  (a) => specialist("You are the ORDERS specialist.", a.customer_message),
  route_to_refunds: (a) => specialist("You are the REFUNDS specialist. Be polite.", a.customer_message),
};
const TOOLS = [
  { name: "route_to_orders", description: "Order status & tracking questions.",
    input_schema: { type: "object", properties: { customer_message: { type: "string" } }, required: ["customer_message"] } },
  { name: "route_to_refunds", description: "Refund & return requests.",
    input_schema: { type: "object", properties: { customer_message: { type: "string" } }, required: ["customer_message"] } },
];
const SYSTEM = "You are a triage agent. Route each message to exactly one specialist tool, then relay its answer.";

async function run(userMsg) {                        // ← identical to M03's orchestration loop
  const messages = [{ role: "user", content: userMsg }];
  for (let i = 0; i < 6; i++) {
    const r = await client.messages.create({ model: MODEL, max_tokens: 1024, system: SYSTEM, tools: TOOLS, messages });
    if (r.stop_reason !== "tool_use")
      return r.content.filter(b => b.type === "text").map(b => b.text).join("");
    messages.push({ role: "assistant", content: r.content });
    const results = [];
    for (const b of r.content)
      if (b.type === "tool_use")
        results.push({ type: "tool_result", tool_use_id: b.id, content: await DISPATCH[b.name](b.input) });
    messages.push({ role: "user", content: results });
  }
}

console.log(await run("I want a refund for order AC-1042."));

// multiagent_claude_sdk.mjs   —   npm i @anthropic-ai/claude-agent-sdk
// Claude Agent SDK subagents: define them, Claude auto-delegates by description.
import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "I want a refund for order AC-1042.",
  options: {
    allowedTools: ["Agent"],                // "Agent" = the delegation tool; required
    agents: {
      orders:  { description: "Order status & tracking questions.",
                 prompt: "You answer order-status questions.", model: "sonnet" },
      refunds: { description: "Refund & return requests.",
                 prompt: "You process refunds and returns politely.", model: "sonnet" },
    },
  },
})) {
  if ("result" in message) console.log(message.result);
}

# multiagent_adk.py   —   pip install google-adk
# ADK: a coordinator with sub_agents; the model emits transfer_to_agent to delegate.
import asyncio
from google.adk.agents import Agent               # Agent == LlmAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types

orders = Agent(name="orders", model="gemini-2.5-flash",
               description="Order status & tracking questions.",
               instruction="Answer order-status questions.")
refunds = Agent(name="refunds", model="gemini-2.5-flash",
                description="Refund & return requests.",
                instruction="Process refunds and returns politely.")
triage = Agent(name="triage", model="gemini-2.5-flash",
               instruction="Route the user to the right specialist.",
               sub_agents=[orders, refunds])        # ← delegation targets

async def main():
    svc = InMemorySessionService()
    await svc.create_session(app_name="support", user_id="u1", session_id="s1")
    runner = Runner(agent=triage, app_name="support", session_service=svc)
    msg = types.Content(role="user", parts=[types.Part(text="I want a refund for order AC-1042.")])
    for event in runner.run(user_id="u1", session_id="s1", new_message=msg):
        if event.is_final_response():
            print(event.content.parts[0].text)

asyncio.run(main())

// multiagent_adk.mjs   —   npm i @google/adk
// ADK: a coordinator with subAgents; the model transfers control to delegate.
import { LlmAgent, Runner, InMemorySessionService } from "@google/adk";

const orders = new LlmAgent({ name: "orders", model: "gemini-2.5-flash",
  description: "Order status & tracking questions.",
  instruction: "Answer order-status questions." });
const refunds = new LlmAgent({ name: "refunds", model: "gemini-2.5-flash",
  description: "Refund & return requests.",
  instruction: "Process refunds and returns politely." });
const triage = new LlmAgent({ name: "triage", model: "gemini-2.5-flash",
  instruction: "Route the user to the right specialist.",
  subAgents: [orders, refunds] });                 // ← delegation targets

const svc = new InMemorySessionService();
const runner = new Runner({ agent: triage, appName: "support", sessionService: svc });
const session = await svc.createSession({ appName: "support", userId: "u1" });
for await (const event of runner.runAsync({
  userId: "u1", sessionId: session.id,
  newMessage: { role: "user", parts: [{ text: "I want a refund for order AC-1042." }] },
})) {
  if (event.isFinalResponse()) console.log(event.content?.parts?.[0]?.text);
}

# multiagent_openai.py   —   pip install openai-agents  (import package: agents)
# OpenAI Agents SDK: handoffs transfer control to the chosen specialist.
import asyncio
from agents import Agent, Runner

orders = Agent(name="Orders", model="gpt-5.5",
               handoff_description="Order status & tracking questions.",
               instructions="You answer order-status questions.")
refunds = Agent(name="Refunds", model="gpt-5.5",
                handoff_description="Refund & return requests.",
                instructions="You process refunds and returns politely.")
triage = Agent(name="Triage", model="gpt-5.5",
               instructions="Route the customer to the right specialist.",
               handoffs=[orders, refunds])          # ← delegation targets

async def main():
    result = await Runner.run(triage, "I want a refund for order AC-1042.")
    print(result.final_output)                      # the specialist's answer
    print("handled by:", result.last_agent.name)    # "Refunds"

asyncio.run(main())

// multiagent_openai.mjs   —   npm i @openai/agents
// OpenAI Agents SDK: handoffs transfer control to the chosen specialist.
import { Agent, run } from "@openai/agents";

const orders = new Agent({ name: "Orders", model: "gpt-5.5",
  handoffDescription: "Order status & tracking questions.",
  instructions: "You answer order-status questions." });
const refunds = new Agent({ name: "Refunds", model: "gpt-5.5",
  handoffDescription: "Refund & return requests.",
  instructions: "You process refunds and returns politely." });
const triage = new Agent({ name: "Triage", model: "gpt-5.5",
  instructions: "Route the customer to the right specialist.",
  handoffs: [orders, refunds] });                  // ← delegation targets

const result = await run(triage, "I want a refund for order AC-1042.");
console.log(result.finalOutput);                   // the specialist's answer
console.log("handled by:", result.lastAgent?.name);