AI Engineering Academy · Oppitunti

Orkestroija–aliagentti-malli

Toteuta orkestroija–aliagentti-malli, jossa suunnittelija-agentti jakaa tehtävät osatehtäviksi, delegoi ne erikoistuneille agenteille ja kokoaa niiden tulokset lopulliseksi tuotokseksi.

Oppitunti 2/413 vaihetta

Orkestroija–aliagentti-malli on ilmainen AI Engineering Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu AI Engineering Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. AI Engineering Academy-kurssilla on yhteensä 4 oppituntia.

Orkestroija–ala-agentti-malli

Orkestroija–ala-agentti-malli on yleisimmin käytetty multi-agent-arkkitehtuuri. Orkestroija-agentti vastaanottaa korkean tason tavoitteen, pilkkoo sen alitehtäviksi, delegoi kunkin alitehtävän erikoistuneelle ala-agentille, kerää tulokset ja yhdistää ne lopulliseksi tuotokseksi. Ajatelkaa orkestroijaa projektipäällikkönä ja ala-agentteja tiimin toimialan asiantuntijoina.

Orkestroijan vastuut

Orkestroijalla on kolme keskeistä vastuuta: hajottaminen (tavoitteen jakaminen konkreettisiksi ja toteutettaviksi alitehtäviksi), delegointi (kunkin alitehtävän osoittaminen oikealle asiantuntijalle) ja yhdistäminen (ala-agenttien tuotosten kokoaminen yhtenäiseksi tulokseksi). Orkestroija itse tekee vain vähän toimialakohtaista työtä — sen arvo syntyy koordinoinnista.

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

Erikoistuneiden ala-agenttien suunnittelu

Jokainen ala-agentti on optimoitu yhtä vastuualuetta varten. Erikoistuminen tarkoittaa seuraavia asioita: roolin määrittävä kohdennettu järjestelmäkehote, pieni joukko (3–5) vain kyseiseen rooliin liittyviä työkaluja sekä konteksti-ikkuna, joka sisältää ainoastaan kyseiseen alitehtävään tarvittavat tiedot. Kohdennetut agentit tekevät parempia päätöksiä, ja niiden arviointi sekä virheenkorjaus on helpompaa.

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
    }

Delegointiprotokolla

Jotta delegointi toimisi, orkestroijan on välitettävä jokaiselle aliagentille hyvin muodostetut tehtäväpaketit. Tehtäväpaketti sisältää tämän aliagentin tarkan tavoitteen, sen tarvitseman olennaisen kontekstin (ei koko keskusteluhistoriaa), odotetun tulostusmuodon sekä mahdolliset rajoitteet. Huonosti muodostetut tehtäväpaketit ovat yleisin orkestroijan ja aliagenttien välisten virheiden lähde.

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)

Tulosten kerääminen ja yhdistäminen

Kun aliagentit ovat saaneet työnsä valmiiksi, orkestroijan on yhdistettävä tulokset. Kyse ei ole pelkästä ketjutuksesta. Orkestroijan on ratkaistava aliagenttien tulosten väliset ristiriidat, täydennettävä puuttuvat kohdat, säilytettävä yhtenäinen tyyli tai muoto ja tuotettava kokonaisuutena johdonmukainen lopputulos. Yhdistämisvaiheessa orkestroijan päättelykykyä tarvitaan eniten.

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

Peräkkäinen ja rinnakkainen delegointi

Orkestroijat voivat delegoida tehtäviä peräkkäin (yhden aliagentin tulos syötetään seuraavalle) tai rinnakkain (useat aliagentit työskentelevät samanaikaisesti). Peräkkäinen delegointi on yksinkertaisempaa ja toimii, kun myöhemmät vaiheet riippuvat aiemmista tuloksista. Rinnakkainen delegointi on nopeampaa, kun alitehtävät ovat toisistaan riippumattomia ja ne voidaan suorittaa samanaikaisesti. Tällöin kokonaisaika voi usein lyhentyä 3–5-kertaisesti.

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)

Aliagenttien virheiden käsittely

Aliagentit epäonnistuvat toisinaan — ne voivat palauttaa virheellisesti muodostettua tulostetta, ylittää iteraatiorajansa tai kohdata virheen. Orkestroijan on käsiteltävä nämä virheet hallitusti. Yleisiä toimintatapoja ovat tehtäväpaketin täsmentäminen ja tehtävän yrittäminen uudelleen, yksinkertaisempaan lähestymistapaan siirtyminen, epäonnistuneen alitehtävän ohittaminen ja sen mainitseminen lopputuloksessa tai asian siirtäminen ihmisen tarkistettavaksi.

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'}

Orkestroijan hyvä ohjeistaminen

Orkestroijan järjestelmäkehote on ratkaisevan tärkeä koko putken laadun kannalta. Siinä on määriteltävä selkeästi, mitä aliagentteja on käytettävissä ja mihin kukin niistä erikoistuu, miten tehtäväpaketit muotoillaan, milloin alitehtävät suoritetaan rinnakkain ja milloin peräkkäin, miten puutteellisia tai ristiriitaisia tuloksia käsitellään sekä mikä katsotaan onnistuneeksi lopputulokseksi.

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

Kontekstin eristäminen on ominaisuus

Orkestroija–aliagentti-mallin merkittävä etu on kontekstin eristäminen. Kukin aliagentti näkee vain alitehtävänsä kannalta olennaiset tiedot, ei koko projektin historiaa. Tämä pitää kunkin aliagentin konteksti-ikkunan pienenä ja ehkäisee yksittäisiä agentteja vaivaavaa kontekstin loppumista. Orkestroija ylläpitää kokonaiskuvaa, kun taas aliagentit ylläpitävät rajattuja paikallisia näkymiä.

Jäljitys ja havainnoitavuus

Moniagenttijärjestelmiä on vaikeampi korjata kuin yksittäisiä agentteja, koska virheitä voi ilmetä missä tahansa delegoinnin vaiheessa. Lisätkää aina rakenteinen lokitus, jolla seurataan, mitä tehtäviä delegoitiin, mille aliagentille, millainen syöte ja tuloste olivat, kuinka kauan kukin tehtävä kesti ja tarvittiinko uudelleenyrityksiä. LangSmithin ja Langfusen kaltaiset työkalut tukevat moniagenttijärjestelmien jälkien visualisointia.

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

Käytännön esimerkki: raporttigeneraattori

Orkestroija–aliagentti-mallin konkreettinen esimerkki on kilpailija-analyysiraporttien generaattori. Orkestroija vastaanottaa pyynnön ”Kirjoita yrityksen X kilpailija-analyysi”. Se delegoi tutkimustehtävän researcher agent -agentille (joka etsii hinnoittelun, ominaisuudet ja arvostelut), analyysitehtävän analyst agent -agentille (joka tunnistaa vahvuudet ja heikkoudet) ja muotoilutehtävän writer agent -agentille (joka tuottaa lopullisen raportin). Kukin asiantuntija tekee sen, missä on parhaimmillaan.

Pikatarkistus

Testatkaa tämän oppitunnin perusteella, kuinka hyvin ymmärrätte orkestroija–aliagentti-mallin.

Vastaa interaktiivisessa oppitunnissa

Oppitunnin kertaus

Tässä oppitunnissa opitte, että orkestroija–aliagentti-malli käyttää koordinoivaa agenttia työn pilkkomiseen ja delegointiin asiantuntijoille, että tehtäväpakettien on määriteltävä selkeästi tavoite, konteksti ja odotettu tulostusmuoto, jotta delegointi toimii, sekä että kontekstin eristäminen pitää kunkin aliagentin ikkunan pienenä orkestroijan säilyttäessä kokonaiskuvan. Seuraavaksi rakennamme moniagenttiputkia LangGraphilla.

Aloita maksutta

Opi Python tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 30
Oppitunnit: 120

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Orkestroija–aliagentti-malli” ilmainen?

Kyllä – oppitunnin ”Orkestroija–aliagentti-malli” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko AI Engineering Academy-kurssin, päivitä CoddyKit PROhon. AI Engineering Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Orkestroija–aliagentti-malli”?

Toteuta orkestroija–aliagentti-malli, jossa suunnittelija-agentti jakaa tehtävät osatehtäviksi, delegoi ne erikoistuneille agenteille ja kokoaa niiden tulokset lopulliseksi tuotokseksi. Harjoittelet AI Engineering Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni AI Engineering Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin AI Engineering Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Orkestroija–aliagentti-malli”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä AI Engineering Academy-oppitunnilla?

Kyllä. Jokainen AI Engineering Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Miksi yksittäiset agentit törmäävät rajoihinsa
Orkestroija–aliagentti-malli
Moniagenttiputkien rakentaminen LangGraphilla
Jaettu muisti ja agenttien välinen viestintä

← Takaisin: AI Engineering Academy