Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Deep Agent Chaining

Les 15 van 18 Bijgewerkt op 28 juli 2026 Ontwikkelaar
Op deze pagina
  1. Ketens van onbeperkte lengte
  2. Drie topologieën en hun gevolgen
  3. Twee productiepijplijnen
  4. De diepte redelijk houden
  5. Belangrijkste punten

Ketens van onbeperkte lengte

De Mistral Agents API legt geen limiet op de diepte van agent-ketens. Eén agent kan het werk overdragen aan een tweede, die het op zijn beurt doorgeeft aan een derde, enzovoort. Deze vrijheid maakt complexe, modulaire workflows mogelijk, maar legt ook de verantwoordelijkheid voor de topologie bij u: u bepaalt wie wie mag aanroepen. Deze kaart bepaalt het gedrag van het systeem net zozeer als de instructies voor elke individuele agent.

Drie topologieën en hun gevolgen

De lineaire keten is het eenvoudigste patroon: elke agent geeft het werk door aan de volgende zonder vertakkingen.

Agent A → Agent B → Agent C → Response

Dit past bij processen waarbij de volgorde vooraf bekend is en nooit verandert. Een typisch voorbeeld is zoeken, vervolgens analyseren en daarna schrijven: u schrijft niet voordat u heeft geanalyseerd, en u analyseert niet voordat u heeft gezocht.

# Research agent
research = client.beta.agents.create(
    model="mistral-large-latest",
    name="research",
    description="Search for factual information.",
    tools=[{"type": "web_search"}]
)

# Analysis agent
analyst = client.beta.agents.create(
    model="mistral-large-latest",
    name="analyst",
    description="Analyze data and extract insights.",
    tools=[{"type": "code_interpreter"}]
)

# Writing agent
writer = client.beta.agents.create(
    model="mistral-large-latest",
    name="writer",
    description="Draft professional reports.",
    instructions="Write a structured report based on the analyzed data."
)

# Chain: research → analyst → writer
research = client.beta.agents.update(
    agent_id=research.id,
    handoffs=[analyst.id]
)

analyst = client.beta.agents.update(
    agent_id=analyst.id,
    handoffs=[writer.id]
)

Elke agent kent alleen zijn directe opvolger: research weet niet eens dat writer bestaat. De keten bestaat alleen in de update-aanroepen, nergens anders.

De ster-keten speelt in op de tegenovergestelde behoefte: een centrale router verdeelt taken onder specialisten die niet met elkaar communiceren.

          ┌→ Web Search Agent
Router ──┼→ Calculator Agent
          └→ Writer Agent
router = client.beta.agents.create(
    model="mistral-large-latest",
    name="router",
    description="Orchestrate requests.",
    handoffs=[research.id, analyst.id, writer.id]
)

Hier is de volgorde niet vooraf bepaald; het verzoek zelf bepaalt de bestemming. Deze vorm past bij veelzijdige assistenten waarbij elk verzoek onder één specifieke competentie valt.

De hybride topologie combineert beide: de router verdeelt, maar specialisten kunnen ook taken aan elkaar doorgeven.

          ┌→ Research Agent ──→ Analyst Agent
Router ──┤                          │
          └→ Writer Agent ←───────────┘
# Research can hand off to Analyst
research = client.beta.agents.update(
    agent_id=research.id,
    handoffs=[analyst.id]
)

# Analyst can hand off to Writer
analyst = client.beta.agents.update(
    agent_id=analyst.id,
    handoffs=[writer.id]
)

# Router can access all
router = client.beta.agents.update(
    agent_id=router.id,
    handoffs=[research.id, analyst.id, writer.id]
)

Dit is de krachtigste vorm, maar ook het moeilijkst om fouten op te sporen. Hetzelfde verzoek kan bij elke uitvoering een ander pad volgen, waardoor logging van overdrachten essentieel wordt zodra u de sandbox verlaat.

Twee productiepijplijnen

Gegevensverwerking illustreert de lineaire keten in zijn meest natuurlijke gebruiksscenario: verzamelen, opschonen, visualiseren. De laatste twee stappen gebruiken dezelfde tool, maar door ze te scheiden blijft elke instructieset helder: opschonen en weergeven zijn distincte taken.

# Step 1: Collection
collector = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-collector",
    description="Collect data from the internet.",
    tools=[{"type": "web_search"}]
)

# Step 2: Cleaning and transformation
transformer = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-transformer",
    description="Clean and transform raw data.",
    tools=[{"type": "code_interpreter"}]
)

# Step 3: Analysis and visualization
visualizer = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-visualizer",
    description="Create visualizations and charts.",
    tools=[{"type": "code_interpreter"}]
)

# Chain
collector = client.beta.agents.update(agent_id=collector.id, handoffs=[transformer.id])
transformer = client.beta.agents.update(agent_id=transformer.id, handoffs=[visualizer.id])

Een academische research-assistent volgt dezelfde structuur, maar met een ander soort tussenschakel. De synthesizer heeft geen tools: zijn waarde ligt volledig in zijn instructies, die hem vragen bronnen met elkaar te confronteren – overeenkomsten, verschillen, lacunes – in plaats van ze simpelweg op te stapelen.

# Searcher
searcher = client.beta.agents.create(
    model="mistral-large-latest",
    name="academic-searcher",
    description="Search for academic articles and publications.",
    tools=[{"type": "web_search"}]
)

# Synthesizer
synthesizer = client.beta.agents.create(
    model="mistral-large-latest",
    name="synthesizer",
    description="Synthesize and compare multiple sources.",
    instructions="Identify common points, divergences, and gaps."
)

# Writer
academic_writer = client.beta.agents.create(
    model="mistral-large-latest",
    name="academic-writer",
    description="Structured academic writing with citations.",
    instructions="Write in academic format with introduction, methodology, results, discussion."
)

# Pipeline: searcher → synthesizer → writer
searcher = client.beta.agents.update(agent_id=searcher.id, handoffs=[synthesizer.id])
synthesizer = client.beta.agents.update(agent_id=synthesizer.id, handoffs=[academic_writer.id])

De diepte redelijk houden

Het ontbreken van een technische limiet is geen uitnodiging om erop los te ketenen. In de praktijk dekt het koppelen van twee tot vier agenten veruit de meeste behoeften. Bij meer dan vijf stijgen zowel de latentie als de kosten scherp. De reden is mechanisch: elke agent voegt zijn eigen contexttokens toe, inclusief instructies, bovenop een conversatiegeschiedenis die sinds de eerste overdracht alleen maar is gegroeid. Een vijfde agent werkt niet op het oorspronkelijke verzoek, maar op alles wat de vorige vier hebben geproduceerd.

Voordat u een keten verlengt, moet u zich afvragen of de extra stap een eigen agent rechtvaardigt, of dat deze past binnen de instructies van een bestaande agent. Een formatteerinstructie bijvoorbeeld rechtvaardigt bijna nooit een extra schakel.

Houd er ook rekening mee dat een agent niet beperkt is tot één doelwit. Het kan meerdere doelwitten declareren en op basis van de context kiezen.

analyst = client.beta.agents.update(
    agent_id=analyst.id,
    handoffs=[writer.id, visualizer.id, calculator.id]
)

Deze analyst zal doorverwijzen naar de writer als het resultaat klaar is om verteld te worden, naar de visualizer als de data om een grafiek vraagt, of naar de calculator als een cijfer nog ontbreekt. De keuze berust, zoals altijd, op de beschrijvingen van de drie doelwitten – de enige informatie die beschikbaar is om de beslissing te nemen.

Belangrijkste punten

  • Geen dieptelimiet voor agent-ketens
  • Drie patronen: lineair (A→B→C), ster (router→specialisten), hybride (grafiek)
  • Elke agent kan meerdere overdrachtdoelen hebben
  • Beperk ketens in productie tot 2–4 agenten om latentie en kosten te beheersen
  • Beschrijvingen van agenten zijn cruciaal voor effectieve routing