Todos los recursos

ArtículoES14 min de lectura24 oct

Automatiza procesos con varios agentes: la guía de prompts

Seis prompts para diseñar, conectar y controlar un equipo de agentes de IA, con diagramas animados y un ejemplo completo de principio a fin.

Un único prompt gigante que «lo hace todo» funciona en la demo y se rompe en producción: no se puede depurar, mezcla responsabilidades y nadie sabe qué parte ha fallado. La alternativa es la de cualquier equipo de personas: roles estrechos, traspasos claros, alguien que revisa y límites que nadie se salta.

Esta guía te da seis prompts, en el orden en que se usan, para diseñar ese equipo con ayuda de un asistente de IA y dejarlo listo para probar. Todo el recorrido usa un mismo ejemplo: el triaje de correos de clientes en una gestoría. Entra un email; sale una respuesta revisada que una persona aprueba antes de enviarse. Sirve igual para cualquier otro proceso.

Diagrama: a la izquierda un único agente saturado de tareas; a la derecha seis agentes encadenados, cada uno con un solo trabajo.
Un único agente con todas las tareas frente a un equipo de seis agentes con un solo trabajo cada uno.

Antes de empezar: ¿necesitas varios agentes?

Si los pasos son siempre los mismos, un flujo fijo que llama al modelo solo donde hace falta lenguaje natural es más barato, más rápido y más fácil de depurar. Varios agentes compensan cuando hay tareas de naturaleza distinta (clasificar, extraer, redactar, revisar), cuando quien revisa no debe ser quien produce, o cuando una parte puede fallar y reintentarse sin repetir todo lo demás. Si dudas, rellena antes la ficha «¿merece este proceso una IA?» de esta misma sección.

Anatomía de un proceso multiagente

  1. Roles estrechos. Cada agente hace una cosa y la hace bien. Un agente con un trabajo claro se puede probar, sustituir y mejorar por separado.
  2. Traspasos tipados. Lo que un agente entrega al siguiente es un dato con esquema (JSON), no un párrafo. Así se valida automáticamente y los errores se detectan en la frontera, no tres pasos después.
  3. Puerta de revisión. Un agente distinto del que produjo el resultado lo evalúa con criterios explícitos y puede rechazarlo con un motivo.
  4. Límites y humano en el bucle. Máximo de pasos, reintentos y coste; permisos mínimos; y aprobación humana antes de cualquier acción irreversible (enviar, pagar, borrar).
Animación: un correo recorre seis agentes (Triage, Extract, Verify, Draft, Review, Send) con contratos entre ellos y una aprobación humana antes del envío.
El correo recorre los seis agentes. Cada traspaso es un contrato y antes del envío hay una aprobación humana.

Los seis prompts

Úsalos en este orden, en una misma conversación con un modelo capaz: la salida de cada uno alimenta al siguiente. Sustituye lo que va entre llaves dobles (por ejemplo {{proceso}}) por tu caso. Cada bloque tiene botón de copiar.

1. Descomponer el proceso en agentes

Parte de un proceso descrito como lo haría una persona y pide que lo trocee en agentes con una sola responsabilidad. Qué obtienes: el mapa del equipo.

Prompt 1 · Descomponer
Eres un arquitecto de sistemas multiagente. Voy a describirte un proceso y quiero que lo diseñes como un equipo de agentes de IA.

Proceso: {{proceso}}
Entrada: {{entrada}}
Resultado esperado: {{salida}}
Restricciones (legales, de privacidad, de tiempo): {{restricciones}}

Haz esto, en orden:
1. Lista los pasos que haría una persona experta, sin pensar todavía en IA.
2. Agrúpalos en agentes. Cada agente: una sola responsabilidad, un nombre de un solo verbo (Triaje, Extractor, Verificador, Redactor, Revisor...), qué recibe y qué entrega.
3. Marca qué pasos NO deben ser un agente (reglas fijas, cálculos, consultas a una base de datos) y qué herramienta o script los resuelve mejor.
4. Indica dónde debe haber una puerta de revisión y dónde una aprobación humana, y por qué.
5. Devuelve una tabla: agente | responsabilidad | entrada | salida | herramientas | riesgo principal.

Reglas: no inventes pasos que no he mencionado; si algo no está claro, pregúntame antes de diseñar. Prefiere menos agentes a más y justifica cada uno con un fallo que evita.

2. Especificar el rol de cada agente

Con el mapa, escribe la instrucción de sistema de cada agente. Cuanto más estrecha, mejor se comporta. Pídela una vez por agente en la misma conversación, para que compartan vocabulario.

Prompt 2 · Rol del agente
Escribe la instrucción de sistema (system prompt) del agente «{{agente}}» de este equipo:

{{mapa_del_equipo}}

Estructura obligatoria:
- MISIÓN: una frase.
- ENTRADA: qué recibe, con un ejemplo real.
- SALIDA: el JSON exacto que debe devolver (si todavía no hay esquema, propón uno mínimo; lo refinaremos en el prompt 3).
- REGLAS: lo que SIEMPRE hace y lo que NUNCA hace, redactado como comprobaciones verificables, no como adjetivos.
- CUÁNDO PARAR: situaciones en las que no actúa y devuelve "necesita_humano" con el motivo.
- EJEMPLOS: dos casos correctos y uno límite con la respuesta ideal.

Reglas: máximo 350 palabras, sin lenguaje motivacional ("eres el mejor..."), sin permisos que el agente no necesite.

3. Definir el contrato de traspaso

Los fallos de un sistema multiagente casi nunca están dentro de un agente: están entre ellos. El contrato fija qué datos viajan y cuándo son válidos, y te permite rechazar al instante lo que llega mal formado sin gastar una llamada al modelo.

Un contrato de traspaso en JSON entre los agentes Extract y Verify, con una insignia de validación de esquema superada.
Un contrato de traspaso entre Extractor y Verificador: campos tipados y una validación automática antes de pasar al siguiente agente.
Prompt 3 · Contrato de traspaso
Define el contrato de traspaso entre el agente «{{origen}}» y el agente «{{destino}}».

Contexto del equipo:
{{mapa_del_equipo}}

Entrégame:
1. Un JSON Schema (draft 2020-12) con tipos, campos obligatorios, formatos (fechas ISO, importes numéricos con moneda) y enumeraciones cerradas.
2. Un ejemplo válido y dos inválidos, con el motivo por el que fallan.
3. Los campos de control que SIEMPRE van: "confianza" (0 a 1), "necesita_humano" (booleano) y "motivo" (texto corto si necesita_humano es true).
4. Las comprobaciones que debe hacer el código (no el modelo) antes de entregar: rangos, coherencia entre campos, valores permitidos.

Reglas: nada de campos de texto libre salvo que sea imprescindible; si hay texto libre, limita su longitud.

4. La puerta de revisión

El revisor no puede ser quien produjo el resultado ni compartir su contexto de «por qué lo hice así». Dale solo la entrada original, el resultado y los criterios. Limita los reintentos (dos suelen bastar) y, si tras el segundo sigue rechazando, escala a una persona en lugar de insistir.

Animación: el agente Review rechaza un borrador por afirmar un plazo que no está en el correo original; tras corregirlo lo aprueba y pasa a aprobación humana.
El Revisor rechaza el borrador por afirmar un plazo que no está en el correo original. Tras la corrección lo aprueba y pasa a aprobación humana.
Prompt 4 · Puerta de revisión
Eres el revisor del agente «{{agente_revisado}}». No colaboras con él: tu trabajo es encontrar motivos para rechazar su resultado.

Entrada original:
{{entrada}}

Resultado a revisar:
{{resultado}}

Criterios (cada uno es una comprobación de sí o no):
{{criterios}}

Devuelve SOLO este JSON:
{
  "veredicto": "aprobar" | "rechazar",
  "fallos": [{"criterio": "...", "evidencia": "cita literal de la entrada o del resultado", "arreglo": "instrucción concreta"}],
  "no_verificable": ["lo que no puedes comprobar con lo que tienes"]
}

Reglas:
- Rechaza si cualquier criterio falla. No existe "aprobado con reservas".
- Cada fallo lleva una cita literal como evidencia; sin cita, no es un fallo.
- Si todo cumple, devuelve "fallos" vacío. No inventes problemas para parecer riguroso.

5. Orquestador, fallos y límites

El orquestador decide el orden, los reintentos y cuándo parar: es lo que convierte seis agentes en un proceso. Importante: los límites los aplica tu código o tu plataforma, no el propio modelo. Un prompt que dice «no gastes más de 5 €» no es un límite.

Panel de control con los límites del proceso: paso 7 de 12, 48 mil de 120 mil tokens, herramientas de solo lectura, el envío de correo requiere aprobación, 1 de 2 reintentos y aprobación humana obligatoria.
Los límites como un panel de control: pasos, tokens, reintentos, permisos de herramientas y aprobación humana.
Prompt 5 · Orquestación y límites
Diseña la política de orquestación de este equipo de agentes:

{{mapa_del_equipo}}

Para cada paso, define:
1. Condición de entrada y de salida.
2. Qué pasa si falla la validación del contrato: cuántos reintentos y con qué cambio (reformular, aportar más contexto, cambiar de modelo).
3. Qué pasa si el revisor rechaza: máximo de rondas y cuándo escalar a una persona.
4. Límites globales: pasos máximos, presupuesto de tokens o de coste, tiempo máximo.
5. Permisos por herramienta: lectura, escritura, y cuáles requieren aprobación humana explícita (enviar, pagar, borrar).
6. Registro: qué se guarda de cada ejecución para poder reconstruir qué pasó (entradas, salidas, veredictos, coste).

Entrega un diagrama en texto (mermaid) y una tabla de límites. Regla: ante la duda entre actuar y escalar, escala.

6. Plan de pruebas

Antes de dejarlo solo, pruébalo con casos de los que conoces la respuesta correcta (un «conjunto dorado») y con casos diseñados para romperlo. Ejecuta el conjunto cada vez que cambies un prompt: si el revisor deja pasar un caso que debía rechazar, ese es el primer arreglo.

Prompt 6 · Plan de pruebas
Genera un plan de pruebas para este proceso multiagente:

{{mapa_del_equipo}}

Crea:
1. 10 casos normales representativos, con la entrada y el resultado esperado.
2. 10 casos límite: datos incompletos, contradictorios, en otro idioma, muy largos, con erratas.
3. 5 casos adversariales: intentos de que un agente ignore sus reglas (instrucciones escondidas en el texto de entrada, peticiones fuera de su alcance).
4. Para cada caso: qué agente debería detectarlo y qué resultado es aceptable (incluido "escalar a una persona").
5. Una métrica de éxito para el conjunto: porcentaje de casos correctos, tasa de falsos aprobados del revisor y coste medio por ejecución.

Devuelve una tabla. No generes datos personales reales: usa nombres e importes ficticios.
Seis fichas numeradas: Decompose, Role spec, Handoff contract, Reviewer gate, Orchestrator and limits, Test plan.
El kit completo de seis prompts, en el orden en que se usan.

El ejemplo completo, en una pasada

Aplicados a la gestoría, los seis prompts dan como resultado este equipo:

  • Triaje clasifica el correo (factura, consulta, urgente, spam) y no escribe nada.
  • Extractor saca datos tipados: cliente, tipo de documento, importe, vencimiento.
  • Verificador contrasta con reglas fijas y con la lista de clientes. Siempre que se pueda, es código, no IA.
  • Redactor prepara la respuesta con la plantilla del despacho.
  • Revisor aplica la puerta de revisión: ¿cita un plazo que no está en el correo? ¿promete algo que el despacho no ofrece?
  • Una persona aprueba. Solo entonces se envía.

Cinco errores que se repiten

  • El agente omnisciente. Si su instrucción ocupa una página, son tres agentes.
  • Traspasos en prosa. «Aquí tienes un resumen» no se puede validar; un JSON con esquema, sí.
  • El revisor es el autor. Quien produjo el resultado tiende a aprobarlo.
  • Límites que viven en el prompt. Los topes de coste, pasos y permisos los aplica el código.
  • Sin humano en lo irreversible. Enviar, pagar y borrar piden aprobación, siempre.

Checklist antes de producción

  • Cada agente tiene una misión de una frase y un ejemplo de entrada y de salida.
  • Todos los traspasos se validan con esquema antes de pasar.
  • El revisor es independiente y sus fallos citan evidencia.
  • Hay un máximo de pasos, reintentos y coste, aplicado por código.
  • Las acciones irreversibles requieren aprobación humana.
  • Se guarda un registro de cada ejecución.
  • Hay un conjunto de pruebas y se ejecuta con cada cambio.