Multi-Agent Use Cases

From Concept to Reality

You now understand handoffs, execution modes, and chaining. This lesson assembles those building blocks into three complete systems, each built on a different topology: an escalation chain, a pipeline, and a router. As you read, notice how the architecture flows from the problem, not the other way around—the nature of the need dictates the form, not the technology.

Case 1: Multi-Tier Customer Support

Support operations run in tiers: most requests resolve at first contact, a minority require technical diagnosis, and a handful end up with a human. This reality maps directly to an escalation chain, where each level transfers only to the next.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Level 1: FAQ and simple questions
level1 = client.beta.agents.create(
    model="mistral-medium-latest",
    name="support-level1",
    description="Level 1 support: FAQ, common questions, basic information.",
    instructions="""You are the first level of support.
- Answer simple questions (hours, rates, FAQ)
- If the question is technical or complex, transfer to level 2
- Be polite and professional""",
    tools=[{"type": "document_library", "library_ids": ["faq-library-id"]}]
)

# Level 2: Technical support
level2 = client.beta.agents.create(
    model="mistral-large-latest",
    name="support-level2",
    description="Technical support: diagnosis, troubleshooting, configuration.",
    instructions="""You are technical support.
- Diagnose technical issues
- Propose step-by-step solutions
- If the problem requires manual intervention, transfer to level 3""",
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}]
)

# Level 3: Human escalation (simulation)
level3 = client.beta.agents.create(
    model="mistral-large-latest",
    name="support-level3",
    description="Escalation: critical issues requiring human intervention.",
    instructions="""Prepare a summary of the issue for the technical team:
- Problem context
- Diagnostic steps performed
- Solutions attempted
- Recommendation"""
)

# Chain the escalations
level1 = client.beta.agents.update(agent_id=level1.id, handoffs=[level2.id])
level2 = client.beta.agents.update(agent_id=level2.id, handoffs=[level3.id])

Two decisions stand out. Level 1 runs on mistral-medium-latest while the subsequent levels use mistral-large-latest. Level 1 absorbs the highest volume, so assigning it the most expensive model would mean paying for unnecessary expertise on questions about business hours. Level 3, meanwhile, solves nothing; it writes a case file. That’s exactly what you want from a human escalation—the engineer taking over receives the context, diagnostic steps already performed, and solutions already attempted, instead of restarting the interrogation from zero.

In practice, a customer writes, “I can’t log in to my account.” Level 1 checks the FAQ, finds no matching case, and transfers. Level 2 diagnoses a database issue beyond its scope and transfers again. Level 3 prepares the ticket with the full history.

Case 2: Strategic Intelligence Pipeline

Here the order is fixed and known in advance: you can’t analyze what hasn’t been collected, or write what hasn’t been analyzed. A linear chain is therefore mandatory, and the entry point isn’t a router but the first link.

# Collector — searches for raw information
collector = client.beta.agents.create(
    model="mistral-large-latest",
    name="intelligence-collector",
    description="Collects strategic information via web search.",
    instructions="""Search for information on the requested topic.
- Cover multiple sources
- Include numerical data
- Note publication dates""",
    tools=[{"type": "web_search"}]
)

# Analyst — extracts insights
analyst = client.beta.agents.create(
    model="mistral-large-latest",
    name="intelligence-analyst",
    description="Analyzes and extracts insights from raw data.",
    instructions="""Analyze the collected data:
- Identify trends
- Spot opportunities and threats
- Quantify when possible""",
    tools=[{"type": "code_interpreter"}]
)

# Reporter — produces the report
reporter = client.beta.agents.create(
    model="mistral-large-latest",
    name="intelligence-reporter",
    description="Writes structured intelligence reports.",
    instructions="""Write a professional intelligence report:
## Executive Summary (3 sentences)
## Key Facts (bullet points)
## Analysis (2-3 paragraphs)
## Recommendations (concrete actions)
## Sources"""
)

# Pipeline
collector = client.beta.agents.update(agent_id=collector.id, handoffs=[analyst.id])
analyst = client.beta.agents.update(agent_id=analyst.id, handoffs=[reporter.id])

# Launch
response = client.beta.conversations.start(
    agent_id=collector.id,
    inputs="Strategic intelligence: sovereign AI market in Europe, Q1 2026."
)

The report outline is written in black and white in the reporter’s instructions, down to the number of sentences in the executive summary. This level of precision is what makes intelligence actionable over time: every report comes out in the same format, allowing you to compare week to week and distribute them without editing. Also note the instruction for the collector to record publication dates—without it, an intelligence report can look solid while relying on outdated sources.

Case 3: The Versatile Assistant

When requests involve unrelated skills, there is neither escalation nor pipeline; there is routing. The central router reads the query and sends it to one of its four specialists, none of whom need to know about the others.

# Specialists
web_researcher = client.beta.agents.create(
    model="mistral-large-latest",
    name="web-researcher",
    description="Searches for current information on the internet.",
    tools=[{"type": "web_search"}]
)

data_analyst = client.beta.agents.create(
    model="mistral-large-latest",
    name="data-analyst",
    description="Data analysis, statistics, and visualizations.",
    tools=[{"type": "code_interpreter"}]
)

doc_expert = client.beta.agents.create(
    model="mistral-large-latest",
    name="doc-expert",
    description="Queries and synthesizes internal documents.",
    tools=[{"type": "document_library", "library_ids": ["docs-lib-id"]}]
)

creative = client.beta.agents.create(
    model="mistral-large-latest",
    name="creative-agent",
    description="Creates visual content and illustrations.",
    tools=[{"type": "image_generation"}]
)

# Central router
assistant = client.beta.agents.create(
    model="mistral-large-latest",
    name="research-assistant",
    description="Versatile research assistant.",
    instructions="""You are a research assistant. Analyze each request and transfer to the appropriate specialist:
- Current information → web-researcher
- Calculations and data → data-analyst
- Questions about our documents → doc-expert
- Need for illustrations → creative-agent""",
    handoffs=[web_researcher.id, data_analyst.id, doc_expert.id, creative.id]
)

Each specialist carries exactly one tool, and the four descriptions do not overlap anywhere. This lack of overlap is what makes routing stable: if two agents could plausibly handle the same request, the choice would vary from one execution to the next, and your users would experience inconsistent quality without understanding why.

What Distinguishes a Prototype from a System

These three systems share the same design rule: one agent, one responsibility. As soon as an agent accumulates two roles, its instructions contradict each other and its description becomes too vague for the router to decide correctly. So write each description with the decision it must enable in mind, and write each set of instructions to state what the agent must not do as well as what it must do.

Moving to production adds four requirements that a prototype ignores. First, logging: client mode lets you trace every handoff with your own identifiers, which will be your only recourse the day a user reports an aberrant response. Second, timeouts, essential on long chains where a stuck link immobilizes the rest. Third, fallbacks, because the question “what happens if this agent fails?” must have a written answer before go-live, not after the first incident. Finally, cost tracking: a three-agent chain consumes tokens at every relay, and only a per-conversation counter will tell you whether your intelligence pipeline costs a few cents or much more.

Key Takeaways

• Multi-tier customer support is a natural use case for handoffs
• Intelligence pipelines (collect → analyze → write) leverage linear chaining
• Versatile assistants use a central router to specialists
• In production: logging, timeouts, fallbacks, and cost monitoring are essential
• One agent = one responsibility, with a precise description for routing