AI Engineering Academy · Lektion

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.

Lektion 2 af 413 trin

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.content

Design 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.content

Sekventiel 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 result

Mø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.

Gratis at komme i gang

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

  1. Hvorfor enkeltstående agenter støder på en grænse
  2. Orchestrator-subagent-mønsteret
  3. Opbygning af multi-agent-pipelines med LangGraph
  4. Delt hukommelse og kommunikation mellem agenter
← Tilbage til AI Engineering Academy