Casos de uso multiagente
En esta página
Del concepto a la realidad
Ya conoces las transferencias, los modos de ejecución y el encadenamiento. Esta lección ensambla esos bloques de construcción en tres sistemas completos, cada uno basado en una topología diferente: una cadena de escalado, una tubería (pipeline) y un enrutador. Mientras lees, fíjate en cómo la arquitectura fluye desde el problema, y no al revés: la naturaleza de la necesidad dicta la forma, no la tecnología.
Caso 1: Atención al cliente multinivel
Las operaciones de soporte funcionan por niveles: la mayoría de las solicitudes se resuelven en el primer contacto, una minoría requiere diagnóstico técnico y un puñado acaba en manos humanas. Esta realidad se mapea directamente con una cadena de escalado, donde cada nivel transfiere únicamente al siguiente.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# Nivel 1: FAQ y preguntas sencillas
level1 = client.beta.agents.create(
model="mistral-medium-latest",
name="support-level1",
description="Soporte de nivel 1: FAQ, preguntas comunes, información básica.",
instructions="""Eres el primer nivel de soporte.
- Responde preguntas sencillas (horarios, tarifas, FAQ)
- Si la pregunta es técnica o compleja, transfiere al nivel 2
- Sé educado y profesional""",
tools=[{"type": "document_library", "library_ids": ["faq-library-id"]}]
)
# Nivel 2: Soporte técnico
level2 = client.beta.agents.create(
model="mistral-large-latest",
name="support-level2",
description="Soporte técnico: diagnóstico, resolución de problemas, configuración.",
instructions="""Eres soporte técnico.
- Diagnostica problemas técnicos
- Propón soluciones paso a paso
- Si el problema requiere intervención manual, transfiere al nivel 3""",
tools=[{"type": "web_search"}, {"type": "code_interpreter"}]
)
# Nivel 3: Escalado humano (simulación)
level3 = client.beta.agents.create(
model="mistral-large-latest",
name="support-level3",
description="Escalado: problemas críticos que requieren intervención humana.",
instructions="""Prepara un resumen del incidente para el equipo técnico:
- Contexto del problema
- Pasos de diagnóstico realizados
- Soluciones intentadas
- Recomendación"""
)
# Encadena los escalados
level1 = client.beta.agents.update(agent_id=level1.id, handoffs=[level2.id])
level2 = client.beta.agents.update(agent_id=level2.id, handoffs=[level3.id])
Dos decisiones destacan. El nivel 1 se ejecuta en mistral-medium-latest, mientras que los niveles posteriores usan mistral-large-latest. El nivel 1 absorbe el mayor volumen, por lo que asignarle el modelo más caro implicaría pagar por una experiencia innecesaria para preguntas sobre horarios comerciales. El nivel 3, por su parte, no resuelve nada; redacta un expediente del caso. Eso es exactamente lo que necesitas de un escalado humano: el ingeniero que toma el relevo recibe el contexto, los pasos de diagnóstico ya realizados y las soluciones ya intentadas, en lugar de reiniciar el interrogatorio desde cero.
En la práctica, un cliente escribe: «No puedo iniciar sesión en mi cuenta». El nivel 1 consulta la FAQ, no encuentra ningún caso coincidente y transfiere. El nivel 2 diagnostica un problema de base de datos fuera de su alcance y vuelve a transferir. El nivel 3 prepara el ticket con todo el historial.
Caso 2: Tubería de inteligencia estratégica
Aquí el orden es fijo y conocido de antemano: no puedes analizar lo que no se ha recogido, ni escribir lo que no se ha analizado. Por tanto, una cadena lineal es obligatoria, y el punto de entrada no es un enrutador, sino el primer eslabón.
# Recopilador — busca información bruta
collector = client.beta.agents.create(
model="mistral-large-latest",
name="intelligence-collector",
description="Recopila información estratégica mediante búsqueda web.",
instructions="""Busca información sobre el tema solicitado.
- Cubre múltiples fuentes
- Incluye datos numéricos
- Anota las fechas de publicación""",
tools=[{"type": "web_search"}]
)
# Analista — extrae conclusiones
analyst = client.beta.agents.create(
model="mistral-large-latest",
name="intelligence-analyst",
description="Analiza y extrae conclusiones de datos brutos.",
instructions="""Analiza los datos recopilados:
- Identifica tendencias
- Detecta oportunidades y amenazas
- Cuantifica cuando sea posible""",
tools=[{"type": "code_interpreter"}]
)
# Redactor — produce el informe
reporter = client.beta.agents.create(
model="mistral-large-latest",
name="intelligence-reporter",
description="Redacta informes de inteligencia estructurados.",
instructions="""Redacta un informe de inteligencia profesional:
## Resumen ejecutivo (3 frases)
## Hechos clave (puntos con viñetas)
## Análisis (2-3 párrafos)
## Recomendaciones (acciones concretas)
## Fuentes"""
)
# Tubería
collector = client.beta.agents.update(agent_id=collector.id, handoffs=[analyst.id])
analyst = client.beta.agents.update(agent_id=analyst.id, handoffs=[reporter.id])
# Lanzamiento
response = client.beta.conversations.start(
agent_id=collector.id,
inputs="Inteligencia estratégica: mercado de IA soberana en Europa, Q1 2026."
)
El esquema del informe está escrito negro sobre blanco en las instrucciones del redactor, hasta el número de frases del resumen ejecutivo. Este nivel de precisión es lo que hace que la inteligencia sea accionable con el tiempo: todos los informes salen con el mismo formato, lo que permite compararlos semana a semana y distribuirlos sin edición. Observa también la instrucción para que el recopilador registre las fechas de publicación; sin ella, un informe de inteligencia puede parecer sólido mientras se basa en fuentes obsoletas.
Caso 3: El asistente versátil
Cuando las solicitudes implican habilidades no relacionadas, no hay escalado ni tubería; hay enrutamiento. El enrutador central lee la consulta y la envía a uno de sus cuatro especialistas, ninguno de los cuales necesita conocer a los demás.
# Especialistas
web_researcher = client.beta.agents.create(
model="mistral-large-latest",
name="web-researcher",
description="Busca información actual en internet.",
tools=[{"type": "web_search"}]
)
data_analyst = client.beta.agents.create(
model="mistral-large-latest",
name="data-analyst",
description="Análisis de datos, estadísticas y visualizaciones.",
tools=[{"type": "code_interpreter"}]
)
doc_expert = client.beta.agents.create(
model="mistral-large-latest",
name="doc-expert",
description="Consulta y sintetiza documentos internos.",
tools=[{"type": "document_library", "library_ids": ["docs-lib-id"]}]
)
creative = client.beta.agents.create(
model="mistral-large-latest",
name="creative-agent",
description="Crea contenido visual e ilustraciones.",
tools=[{"type": "image_generation"}]
)
# Enrutador central
assistant = client.beta.agents.create(
model="mistral-large-latest",
name="research-assistant",
description="Asistente de investigación versátil.",
instructions="""Eres un asistente de investigación. Analiza cada solicitud y transfiere al especialista adecuado:
- Información actual → web-researcher
- Cálculos y datos → data-analyst
- Preguntas sobre nuestros documentos → doc-expert
- Necesidad de ilustraciones → creative-agent""",
handoffs=[web_researcher.id, data_analyst.id, doc_expert.id, creative.id]
)
Cada especialista lleva exactamente una herramienta, y las cuatro descripciones no se solapan en ningún punto. Esta falta de solapamiento es lo que hace estable el enrutamiento: si dos agentes pudieran gestionar plausiblemente la misma solicitud, la elección variaría de una ejecución a otra, y tus usuarios experimentarían una calidad inconsistente sin entender por qué.
Qué distingue un prototipo de un sistema
Estos tres sistemas comparten la misma regla de diseño: un agente, una responsabilidad. En cuanto un agente acumula dos roles, sus instrucciones se contradicen entre sí y su descripción se vuelve demasiado vaga para que el enrutador decida correctamente. Por tanto, escribe cada descripción pensando en la decisión que debe habilitar, y redacta cada conjunto de instrucciones para declarar tanto lo que el agente debe hacer como lo que no debe hacer.
Pasar a producción añade cuatro requisitos que un prototipo ignora. Primero, el registro (logging): el modo cliente te permite rastrear cada transferencia con tus propios identificadores, que serán tu único recurso el día que un usuario informe de una respuesta aberrante. Segundo, los tiempos de espera (timeouts), esenciales en cadenas largas donde un eslabón bloqueado inmoviliza al resto. Tercero, los mecanismos de respaldo (fallbacks), porque la pregunta «¿qué ocurre si falla este agente?» debe tener una respuesta por escrito antes del lanzamiento, no después del primer incidente. Por último, el seguimiento de costes: una cadena de tres agentes consume tokens en cada relevo, y solo un contador por conversación te dirá si tu tubería de inteligencia cuesta unos céntimos o mucho más.
Puntos clave
- La atención al cliente multinivel es un caso de uso natural para las transferencias
- Las tuberías de inteligencia (recopilar → analizar → escribir) aprovechan el encadenamiento lineal
- Los asistentes versátiles utilizan un enrutador central hacia especialistas
- En producción: el registro, los tiempos de espera, los respaldos y el seguimiento de costes son esenciales
- Un agente = una responsabilidad, con una descripción precisa para el enrutamiento