Orchestrator-subagent-mønsteret
Implementér orchestrator-subagent-mønsteret, hvor en planlægningsagent opdeler opgaver i delopgaver, delegerer dem til specialiserede agenter og sammenfatter deres resultater til et endeligt output.
Orchestrator-subagent-mønsteret er en gratis AI Engineering Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI Engineering Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI Engineering Academy-kurset indeholder 4 lektioner i alt.
Den mentale model for orkestrator og underagenter
Orkestrator-underagent-mønsteret er den mest udbredte multi-agentarkitektur. En orkestrator modtager et overordnet mål, opdeler det i delopgaver, uddelegerer hver delopgave til en specialiseret underagent, indsamler resultaterne og syntetiserer et endeligt output. Tænk på orkestratoren som en projektleder og underagenterne som domæneeksperter på teamet.
Orkestratorens ansvarsområder
Orkestratoren har tre centrale ansvarsområder: opdeling (at bryde målet ned i konkrete, handlingsorienterede delopgaver), delegering (at tildele hver delopgave til den rette specialist) og syntese (at kombinere underagenternes output til et sammenhængende resultat). Orkestratoren udfører selv kun minimalt domænespecifikt arbejde — dens værdi ligger i koordineringen.
from openai import OpenAI
client = OpenAI()
def orchestrator(goal: str) -> dict:
# Step 1: Decompose
plan = client.chat.completions.create(
model='gpt-4o',
messages=[
{'role': 'system', 'content': 'You are a task planner. Decompose the goal into subtasks. Return JSON with keys: researcher_task, writer_task, coder_task.'},
{'role': 'user', 'content': goal}
],
response_format={'type': 'json_object'}
)
return plan.choices[0].message.contentDesign af specialiserede underagenter
Hver underagent er optimeret til ét ansvarsområde. Specialisering betyder: en fokuseret systemprompt, der definerer rollen, et lille sæt værktøjer (3-5), som kun er relevante for denne rolle, og et kontekstvindue, der kun indeholder de oplysninger, der er nødvendige for delopgaven. Fokuserede agenter træffer bedre beslutninger og er lettere at evaluere og fejlfinde.
def create_researcher_agent():
return {
'model': 'gpt-4o',
'system': '''You are a research specialist. Your only job is to find accurate,
cited information. Return structured findings with sources.
Do NOT write prose or code - only research findings.''',
'tools': ['search_web', 'fetch_url', 'query_arxiv'], # 3 tools only
'max_iterations': 10
}
def create_writer_agent():
return {
'model': 'gpt-4o',
'system': '''You are a technical writer. Transform research findings into clear,
engaging prose. You receive structured data and return polished text.''',
'tools': ['format_markdown', 'check_readability'], # 2 tools only
'max_iterations': 5
}Delegeringsprotokollen
For at delegering kan fungere, skal orkestratoren sende velformaterede opgavepakker til hver underagent. En opgavepakke indeholder: det specifikke mål for denne underagent, den relevante kontekst, den har brug for (ikke hele samtalehistorikken), det forventede outputformat og eventuelle begrænsninger. Dårligt formaterede opgavepakker er den hyppigste årsag til fejl mellem orkestrator og underagenter.
from dataclasses import dataclass
from typing import Optional
@dataclass
class TaskPacket:
task_id: str
assignee: str # which subagent receives this
goal: str # specific, actionable goal
context: str # only relevant background
output_format: str # JSON schema or description
constraints: list[str] # e.g. ['max 500 words', 'cite sources']
deadline_steps: int # max iterations allowed
def delegate(packet: TaskPacket, subagent_fn) -> str:
prompt = f'Goal: {packet.goal}\nContext: {packet.context}\nOutput format: {packet.output_format}\nConstraints: {packet.constraints}'
return subagent_fn(prompt)Indsamling og sammenfatning af resultater
Når underagenterne har afsluttet deres arbejde, skal orkestratoren sammenfatte resultaterne. Det handler ikke bare om sammenkædning. Orkestratoren skal løse konflikter mellem underagenternes output, udfylde huller, bevare en ensartet stil eller et ensartet format og producere et endeligt resultat, der hænger sammen som helhed. Det er i sammenfatningstrinnet, at orkestratorens evne til at ræsonnere er mest nødvendig.
def synthesize_results(research: str, draft: str, code: str, goal: str) -> str:
synthesis_prompt = f'''You are given outputs from three specialist agents.
Your job is to synthesize them into one coherent final answer for this goal: {goal}
RESEARCH FINDINGS:
{research}
WRITTEN DRAFT:
{draft}
CODE EXAMPLES:
{code}
Resolve any conflicts, fill gaps, and produce a unified final response.
'''
response = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': synthesis_prompt}]
)
return response.choices[0].message.contentSekventiel kontra parallel delegering
Orkestratorer kan delegere opgaver sekventielt (én underagents output bliver input til den næste) eller parallelt (flere underagenter arbejder samtidigt). Sekventiel delegering er enklere og fungerer, når senere trin afhænger af tidligere resultater. Parallel delegering er hurtigere, når delopgaverne er uafhængige og kan køre samtidigt, og kan ofte reducere den samlede kørselstid 3-5 gange.
import asyncio
# Sequential: writer needs research first
async def sequential_pipeline(goal):
research = await researcher_agent(goal)
draft = await writer_agent(research) # depends on research
return draft
# Parallel: all three tasks are independent
async def parallel_pipeline(topics):
tasks = [
researcher_agent(topics[0]),
researcher_agent(topics[1]),
researcher_agent(topics[2])
]
results = await asyncio.gather(*tasks) # runs simultaneously
return orchestrator_synthesize(results)Håndtering af fejl i underagenter
Underagenter vil af og til fejle — de kan returnere forkert formateret output, overskride deres iterationsgrænse eller støde på en fejl. Orkestratoren skal håndtere disse fejl på en robust måde. Almindelige strategier omfatter: prøv igen med en tydeligere opgavepakke, brug en enklere alternativ løsning, spring den fejlslagne delopgave over og noter det i det endelige output, eller eskalér til menneskelig gennemgang.
def delegate_with_retry(packet: TaskPacket, subagent_fn, max_retries=2):
for attempt in range(max_retries + 1):
try:
result = subagent_fn(packet)
validate_output(result, packet.output_format)
return result
except ValidationError as e:
if attempt < max_retries:
# Clarify the task for retry
packet.goal += f'\n\nPrevious attempt failed: {str(e)}. Please fix.'
print(f'Retry {attempt + 1} for task {packet.task_id}')
else:
return {'error': str(e), 'task_id': packet.task_id, 'status': 'failed'}Sådan skriver du gode prompts til orkestratoren
Orkestratorens systemprompt er afgørende for kvaliteten af hele arbejdsgangen. Den bør tydeligt definere: hvilke underagenter der er tilgængelige, og hvad hver af dem er specialiseret i, hvordan opgavepakker skal formateres, hvornår delopgaver skal køres parallelt kontra sekventielt, hvordan ufuldstændige eller modstridende resultater skal håndteres, og hvad der udgør et vellykket endeligt output.
ORCHESTRATOR_SYSTEM_PROMPT = '''
You coordinate a team of specialist agents to complete complex tasks.
Available agents:
- researcher: Finds and cites factual information. Input: question string. Output: JSON with findings and sources.
- writer: Writes polished prose from structured data. Input: JSON findings. Output: markdown text.
- coder: Writes Python code. Input: natural language spec. Output: Python code string.
Workflow:
1. Analyze the goal and decide which agents are needed.
2. Identify dependencies: can any tasks run in parallel?
3. Delegate tasks with clear, specific goals.
4. Validate each result before proceeding.
5. Synthesize all results into a unified final answer.
'''Kontekstisolering er en fordel
En væsentlig fordel ved mønsteret med orkestrator og underagenter er kontekstisolering. Hver underagent ser kun de oplysninger, der er relevante for dens delopgave, ikke hele historikken for projektet. Det holder hver underagents kontekstvindue lille og forhindrer den kontekstudtømning, som plager enkeltstående agenter. Orkestratoren bevarer det globale overblik, mens underagenterne bevarer fokuserede lokale perspektiver.
Sporing og observerbarhed
Systemer med flere agenter er sværere at fejlfinde end enkeltstående agenter, fordi fejl kan opstå ved hvert delegeringstrin. Tilføj altid struktureret logning for at spore: hvilke opgaver der blev delegeret, til hvilken underagent, hvad inputtet og outputtet var, hvor lang tid hver opgave tog, og om det var nødvendigt at prøve igen. Værktøjer som LangSmith og Langfuse understøtter visualisering af spor i systemer med flere agenter.
import time
def logged_delegate(packet: TaskPacket, subagent_fn):
start = time.time()
print(f'[DELEGATE] task_id={packet.task_id} assignee={packet.assignee}')
print(f'[INPUT] {packet.goal[:100]}...')
result = subagent_fn(packet)
elapsed = time.time() - start
print(f'[RESULT] task_id={packet.task_id} elapsed={elapsed:.2f}s')
print(f'[OUTPUT] {str(result)[:100]}...')
return resultMønster fra den virkelige verden: Rapportgenerator
Et konkret eksempel på mønsteret med orkestrator og underagenter er en rapportgenerator til konkurrentanalyse. Orkestratoren modtager »Skriv en konkurrentanalyse for Virksomhed X«. Den delegerer: en researchopgave til en researcher-agent (finder priser, funktioner og anmeldelser), en analyseopgave til en analyst-agent (identificerer styrker og svagheder) og en formateringsopgave til en writer-agent (producerer den endelige rapport). Hver specialist gør det, den er bedst til.
Hurtigt tjek
Test din forståelse af mønsteret med orkestrator og underagenter fra denne lektion.
Opsummering af lektionen
I denne lektion har du lært, at mønsteret med orkestrator og underagenter bruger en koordinerende agent til at opdele og delegere arbejde til specialister, at opgavepakker tydeligt skal definere mål, kontekst og forventet outputformat, for at delegering kan fungere, og at kontekstisolering holder hver underagents vindue lille, mens orkestratoren bevarer det globale overblik. Nu bygger vi arbejdsgange med flere agenter ved hjælp af LangGraph.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Orchestrator-subagent-mønsteret” gratis?
Ja — hele teksten til “Orchestrator-subagent-mønsteret” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI Engineering Academy-kurset, skal du opgradere til CoddyKit PRO. AI Engineering Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Orchestrator-subagent-mønsteret”?
Implementér orchestrator-subagent-mønsteret, hvor en planlægningsagent opdeler opgaver i delopgaver, delegerer dem til specialiserede agenter og sammenfatter deres resultater til et endeligt output. Du øver dig i AI Engineering Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på AI Engineering Academy?
Der kræves ingen tidligere erfaring. AI Engineering Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Orchestrator-subagent-mønsteret”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne AI Engineering Academy-lektion?
Ja. Alle AI Engineering Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Hvorfor enkeltstående agenter støder på en grænse
- Orchestrator-subagent-mønsteret
- Opbygning af multi-agent-pipelines med LangGraph
- Delt hukommelse og kommunikation mellem agenter