{"title":"Exercise: Multi-Agent Systems","description":null,"content":"# Exercise 1: Route Tasks to Specialist Agents\n\nBuild a coordinator that sends each task to the right specialist agent. A router classifies the task, then the matching specialist (each just a model call with its own system prompt) handles it.\n\nA single general-purpose prompt does many things adequately and nothing excellently. The multi-agent pattern splits work across specialists, each with a focused role, and uses a coordinator to route. The router is the key piece: it reads the task and picks the specialist, the same way a team lead assigns work to the right person.\n\n### Requirements\n\n- Define two specialists with distinct system prompts, for example a `code` expert and a `writing` expert.\n- Write a router that classifies each task as `code` or `writing`.\n- Send each task to the chosen specialist and collect the response.\n- Print which specialist handled each task and its answer.\n\n\n**main.py**\n\n```python\nfrom openai import OpenAI\n\nclient = OpenAI() # Uses OPENAI_API_KEY from environment\n\nspecialists = {\n \"code\": \"You are a senior software engineer. Answer with correct, concise code or technical guidance.\",\n \"writing\": \"You are a professional editor. Improve clarity and tone in plain language.\",\n}\n\ntasks = [\n \"Write a Python function to reverse a linked list.\",\n \"Rewrite this sentence to be more concise: 'In order to begin, you should first start by initializing.'\",\n]\n\ndef route(task: str) -> str:\n # TODO: ask the model to classify the task as \"code\" or \"writing\".\n # Return the lowercased label.\n pass\n\ndef handle(task: str) -> tuple:\n # TODO: route the task, send it to the matching specialist, and return\n # (specialist_name, answer)\n pass\n\n# TODO: for each task, handle it and print the specialist and the answer\n```\n\n\n### Expected Output\n\nThe coding task goes to the code specialist; the rewrite goes to the writing specialist.\n\n\n```plaintext\n[code] Write a Python function to reverse a linked list.\n -> def reverse(head): ...\n\n[writing] Rewrite this sentence to be more concise: ...\n -> To begin, initialize first.\n```\n\n\n### Solution\n\n\n**main.py**\n\n```python\nfrom openai import OpenAI\n\nclient = OpenAI()\n\nspecialists = {\n \"code\": \"You are a senior software engineer. Answer with correct, concise code or technical guidance.\",\n \"writing\": \"You are a professional editor. Improve clarity and tone in plain language.\",\n}\n\ntasks = [\n \"Write a Python function to reverse a linked list.\",\n \"Rewrite this sentence to be more concise: 'In order to begin, you should first start by initializing.'\",\n]\n\ndef route(task: str) -> str:\n response = client.chat.completions.create(\n model=\"gpt-5.4-mini\",\n messages=[\n {\n \"role\": \"system\",\n \"content\": (\n \"Classify the task. Reply with exactly one word: 'code' for programming \"\n \"or technical tasks, or 'writing' for editing or text tasks.\"\n ),\n },\n {\"role\": \"user\", \"content\": task},\n ],\n )\n return response.choices[0].message.content.strip().lower()\n\ndef handle(task: str) -> tuple:\n specialist = route(task)\n response = client.chat.completions.create(\n model=\"gpt-5.4-mini\",\n messages=[\n {\"role\": \"system\", \"content\": specialists[specialist]},\n {\"role\": \"user\", \"content\": task},\n ],\n )\n return specialist, response.choices[0].message.content.strip()\n\nfor task in tasks:\n specialist, answer = handle(task)\n print(f\"[{specialist}] {task}\")\n print(f\" -> {answer}\\n\")\n```\n\n\nThe coordinator splits one decision (route) from the work (handle), so each specialist can have a tightly focused prompt instead of one prompt trying to cover everything. Routing with a cheap classification call keeps the system simple and cheap, and the design scales by adding entries to the `specialists` map. This same shape underlies larger multi-agent systems, where specialists may themselves use tools or hand work to one another.\n\n---\n\n# Exercise 2: Plan, Delegate, and Synthesize\n\nRouting sends a whole task to one specialist; a manager pattern goes further by breaking a task into subtasks, handling each, and combining the results. Build a planner that splits a task in two, a worker that completes each subtask, and a synthesis step that merges them into one result.\n\n### Requirements\n\n- Write `plan(task)` that asks the model for two subtasks.\n- Write `do_subtask(subtask)` that completes a single subtask.\n- Plan, run each subtask, then synthesize the parts into one final result. Print the subtasks, their results, and the synthesis.\n\n\n**main.py**\n\n```python\nfrom openai import OpenAI\nimport json\n\nclient = OpenAI() # Uses OPENAI_API_KEY from environment\n\ntask = \"Write a short launch announcement for a new caching feature, and include one example use case.\"\n\ndef plan(task):\n # TODO: ask the model to break the task into 2 subtasks, one per line\n ...\n\ndef do_subtask(subtask):\n # TODO: complete a single subtask concisely\n ...\n\n# TODO: plan the task, do each subtask, then synthesize the parts into one final result.\n# Print the subtasks, each result, and the synthesis.\n```\n\n\n### Expected Output\n\nThe task splits into writing the announcement and the example, each is done separately, and the synthesis merges them.\n\n\n```plaintext\n- Write the launch announcement for the caching feature\n Introducing our new caching layer: faster responses with less load...\n- Provide one example use case\n A product catalog API caches hot queries, cutting p95 latency in half...\n\nFinal: Introducing our new caching layer... For example, a product catalog API caches hot queries, cutting p95 latency in half.\n```\n\n\n### Solution\n\n\n**main.py**\n\n```python\nfrom openai import OpenAI\nimport json\n\nclient = OpenAI() # Uses OPENAI_API_KEY from environment\n\ntask = \"Write a short launch announcement for a new caching feature, and include one example use case.\"\n\ndef plan(task):\n response = client.chat.completions.create(\n model=\"gpt-5.4-mini\",\n messages=[{\"role\": \"system\", \"content\": \"Break the task into exactly 2 subtasks, one per line, no numbering.\"},\n {\"role\": \"user\", \"content\": task}],\n )\n return [s.strip() for s in response.choices[0].message.content.splitlines() if s.strip()]\n\ndef do_subtask(subtask):\n response = client.chat.completions.create(\n model=\"gpt-5.4-mini\",\n messages=[{\"role\": \"user\", \"content\": subtask}],\n )\n return response.choices[0].message.content.strip()\n\nsubtasks = plan(task)\nresults = [do_subtask(s) for s in subtasks]\nfor s, r in zip(subtasks, results):\n print(f\"- {s}\\n {r}\\n\")\n\nsynthesis = client.chat.completions.create(\n model=\"gpt-5.4-mini\",\n messages=[{\"role\": \"system\", \"content\": \"Combine the parts into one polished result for the original task.\"},\n {\"role\": \"user\", \"content\": f\"Task: {task}\\n\\nParts:\\n\" + \"\\n\".join(results)}],\n)\nprint(\"Final:\", synthesis.choices[0].message.content.strip())\n```\n\n\nDecomposition lets each subtask get the model's full attention with a focused prompt, instead of one prompt juggling everything. The synthesis step is where the parts become a coherent whole, and giving the synthesizer the original task plus all the parts keeps the result on target. This plan-delegate-synthesize loop is the backbone of manager-style multi-agent systems, where the subtasks might themselves go to different specialists or use tools.","pageType":"ai-engineering"}

Get Premium