Agentes y flujos de trabajo: Construir flujos de agentes para sistemas

Guía técnica y práctica para diseñar, implementar, probar y escalar flujos de trabajo con agentes en sistemas de producción para una automatización fiable y auditable.

Copy&Prompt TEAM · Publicado 2026-08-05 · Actualizado 2026-08-05

Respuesta rápida

Los flujos de agentes combinan agentes LLM de estilo planificador con pasos de flujo de trabajo deterministas e integraciones de herramientas. Constrúyalos definiendo roles claros, prompts estructurados, formatos de salida deterministas, barreras de seguridad y observabilidad. Pruebe con suites de regresión, validación de esquemas y escenarios de caos antes de pasar a producción.

Contenido

1. ¿Qué problema resuelven los flujos de agentes?
2. Método: patrón de diseño para flujos de agentes
3. Paso 1: Definir objetivos, roles y herramientas
4. Paso 2: Componer los prompts del sistema y del planificador
5. Paso 3: Salida estructurada y esquemas JSON
6. Paso 4: Orquestación y planes alternativos
7. Ejemplos aplicados
8. Tabla comparativa: flujos vs agentes vs híbrido
9. Errores comunes — Error → Por qué → Solución
10. Limitaciones — lo que esto no resuelve
11. Escalar: almacenar, versionar, compartir
12. Cómo verificar el éxito
13. Solución de problemas
14. Rol de Copy&Prompt
15. Preguntas frecuentes

¿Qué problema resuelven los flujos de agentes?

Los flujos de agentes permiten que los sistemas usen modelos de lenguaje grande para planificar, decidir y llamar a herramientas mientras mantienen una orquestación determinista para mayor fiabilidad. Resuelven tareas que requieren tanto razonamiento abierto como efectos secundarios precisos: recopilación de datos en varios pasos, automatización con múltiples herramientas y lógica de negocio condicionada. En resumen: conectan la creatividad del modelo con el control del sistema.

Método: patrón de diseño para flujos de agentes

Un flujo de agentes es un sistema por capas. Las capas son planificador (agente), ejecutor (motor de flujo), adaptadores de herramientas (APIs), almacenamiento de datos (índice RAG, BD) y observabilidad (logs, trazas). El diseño comienza con un objetivo preciso, luego define prompts por rol y contratos deterministas entre capas. El resultado es un comportamiento repetible y modos de fallo testeables.

Principios

• Separación de roles: planificador frente a ejecutor de acciones.
• Contratos estructurados: salidas JSON que el ejecutor parsea.
• Acciones idempotentes cuando sea posible.
• Ventanas de contexto cortas para herramientas; empuje el contexto largo a almacenes RAG.
• Fallbacks de fallo rápido y puntos de control con intervención humana.

Paso 1: Definir objetivos, roles y herramientas

Empiece escribiendo criterios de éxito en una sola frase para el flujo. Luego mapea los roles y las herramientas que el agente puede invocar.

Ejemplo: "Producir una presentación de 10 diapositivas a partir de un brief de producto, con citas y una llamada al servicio generador de diapositivas." Esto genera roles: Planificador, Investigador, API de diapositivas. Herramientas: web-scraper, KB interna (RAG), API generadora de diapositivas, almacenamiento con credenciales.

Lista de comprobación para roles y herramientas

• Objetivo: salida única y medible.
• Acciones permitidas: lista de llamadas a herramientas y sus firmas de API exactas.
• Acciones prohibidas: p. ej., no enviar correos salientes sin aprobación humana.
• Fuentes de datos y requisitos de frescura, con TTL.

Paso 2: Componer los prompts del sistema y del planificador

Escriba un prompt de sistema que establezca el rol, las restricciones y el contrato de salida. Luego escriba un prompt de planificador que produzca un plan de pasos en formato amigable para máquinas. Mantenga ambos cortos y deterministas.

La salida del planificador debe estar estructurada. Eso reduce los errores del parser y hace que las pruebas de regresión sean confiables.

Produce: un plan de pasos como JSON con llamadas a herramientas y razones.

Rol: Sistema
Contexto: Eres el Planificador para un flujo de agentes que convierte un brief en una presentación de diapositivas.
Tarea: Produce un plan JSON que liste pasos ordenados. Cada paso debe incluir "action", "tool", "input", "expected_output_schema".
Restricciones:
- Máx. 7 pasos.
- Usa solo herramientas en [ALLOWED_TOOLS].
- Incluye un flotante "confidence" entre 0 y 1.
Formato de salida: arreglo JSON de pasos.

Por qué funciona: forzar un plan en JSON reduce los errores del parser en la capa de orquestación. Validado en ChatGPT (gpt-4o), agosto de 2026.

Notas sobre el prompt del planificador

Siempre variabilice las herramientas permitidas y las reglas de negocio en [BRACKETS_UPPERCASE]. Eso permite que su código sustituya contexto en tiempo de ejecución. Evite listas en lenguaje natural como contrato primario.

Paso 3: Salida estructurada y esquemas JSON

Los formatos de salida deterministas son la barrera de seguridad más importante. Trate cada salida del LLM como no confiable hasta que pase la validación de esquema.

Defina JSON Schema para cada salida de paso. El ejecutor rechaza o reintenta las salidas que no pasan la validación.

{
  "$id": "https://example.com/schemas/slide-plan.json",
  "type": "object",
  "properties": {
    "slides": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "title": {"type": "string"},
          "bullets": {"type": "array", "items": {"type": "string"}},
          "sources": {"type": "array", "items": {"type": "string"}}
        },
        "required": ["title","bullets"]
      }
    }
  },
  "required": ["slides"]
}

Por qué funciona: la validación de esquemas aísla las alucinaciones y exige campos para las herramientas downstream.

Paso 4: Orquestación y planes alternativos

El ejecutor convierte los pasos del planificador en llamadas a APIs. Haga cada paso idempotente cuando sea posible. Añada tres estrategias de fallback: reintento automático con jitter, escalar a una herramienta secundaria y aprobación humana.

Diseñe una máquina de estados para el flujo. Cada transición debe registrar entradas, salidas y el prompt del modelo utilizado. Eso hace que la depuración sea reproducible.

Ejemplos aplicados

Incluimos dos ejemplos compactos y del mundo real: investigación+resumen y conciliación de facturas. Cada uno muestra la salida del planificador, el mapeo del ejecutor y un caso de fallo.

Ejemplo A — Investigación + resumen

Objetivo: reunir tres fuentes autorizadas sobre el tema X y producir un breve de 300 palabras con citas.

• El planificador produce pasos: buscar en la web, obtener artículos del KB, sintetizar el resumen.
• El ejecutor mapea "buscar en la web" al adaptador del scraper con límites de tasa.
• Modo de fallo: el scraper devuelve CAPTCHA → fallback: usar KB en caché y añadir la bandera "data_gap".

Ejemplo B — Conciliación de facturas

Objetivo: emparejar facturas de proveedores con pagos y marcar discrepancias.

• El planificador organiza pasos: obtener el libro mayor, extraer entidades de facturas, emparejar por importe y fecha, producir informe CSV.
• Use un esquema de extracción de entidades estricto para importes y fechas para evitar emparejamientos difusos.
• Modo de fallo: confianza de emparejamiento ambigua < 0.6 → enrutar a la cola humana con adjuntos.

Comparación: flujos vs agentes vs híbrido

Esta tabla resume casos de uso recomendados, complejidad y requisitos de observabilidad.

Errores comunes — Error → Por qué → Solución

• Error: Permitir que el planificador llame APIs arbitrarias.
  Por qué: Crea problemas de seguridad y auditoría.
  Solución: Lista blanca de herramientas y aplicar autenticación a nivel de adaptador.
• Error: No validar esquemas en las salidas.
  Por qué: Los campos alucinados rompen el código downstream.
  Solución: Rechazar y reintentar con prompt aclaratorio y ejemplos.
• Error: Almacenar prompts solo en notas.
  Por qué: Los prompts derivan y son difíciles de reproducir.
  Solución: Usar una biblioteca de prompts versionada y comprobaciones en CI.

Limitaciones: lo que esto no resuelve

Los flujos de agentes no sustituyen a los validadores específicos del dominio ni a la integridad transaccional. No pueden garantizar corrección frente a entradas adversariales sin comprobaciones externas. Además, el comportamiento y la latencia del modelo variarán entre proveedores. Diseñe pensando en el cambio: versionee prompts y modelos, y asuma regresiones tras actualizaciones del modelo.

Observación: en Claude Opus (Anthropic), observamos bucles de planificación que repiten un paso tres veces a menos que se detuvieran con una guarda de iteraciones máximas (observado agosto de 2026). Eso requirió una regla explícita de "stop" en el prompt del planificador.

Escalar: almacenar, versionar, compartir

Haga que los prompts y los esquemas sean artefactos de primera clase. Use un registro de prompts con etiquetas semánticas, versiones y pruebas. Trate un prompt como código: PRs, revisión y comprobaciones automatizadas. Los tres artefactos a almacenar por flujo son paquetes de prompts, archivos de esquema y especificaciones de adaptadores.

Copy&Prompt es una biblioteca de prompts que le permite optimizar, almacenar, compartir y copiar prompts con un clic en ChatGPT, Claude, Gemini, DeepSeek, Lovable y Midjourney.

Lista de comprobación de versionado

• Hash del prompt y diff semántico.
• Versión del contrato de esquema.
• Modelo y fecha para cada ejecución de validación.
• Pruebas de regresión automatizadas en CI.

Cómo verificar que tiene éxito

Use tres clases de pruebas: unitarias (single prompt → esquema), de integración (planificador → ejecutor → herramienta) y de caos (simular fallos de API y latencia). Rastree estas métricas: tasa de éxito por paso, reintentos promedio, escalados a humanos por cada 1.000 ejecuciones.

Criterios de aceptación de ejemplo para un generador de presentaciones:

• El planificador produce un plan JSON válido en el 95% de los ensayos.
• El ejecutor completa la generación de diapositivas sin aprobación manual en el 90% de los casos.
• Máx. un reintento por llamada a herramienta fallida en promedio.

Qué hacer si no funciona

Triée rápido con estos pasos.

1. Reproduzca la ejecución fallida con los prompts exactos y la versión del modelo.
2. Valide la salida JSON del planificador contra el esquema.
3. Revise los logs del adaptador de la herramienta por errores de API o límites de tasa.
4. Si el planificador entra en bucle, añada límites de iteración y requiera tokens "next_step".
5. Si ocurren alucinaciones, aumente el grounding con recuperación o citas explícitas.

Prompts copiables y ejemplos de esquemas de ejecutor

Más abajo hay tres bloques de prompts con sello de modelo. Péguelos tal cual y reemplace las variables entre corchetes.

Produce: un extractor que devuelve entidades normalizadas para facturas.

Rol: Agente Extractor
Contexto: Extraer datos de facturas desde texto OCR bruto.
Tarea: Devuelve un objeto JSON con claves: invoice_id, vendor_name, date (ISO), amount (decimal), currency.
Restricciones:
- Las fechas deben estar en ISO-8601.
- Los importes deben ser únicamente numéricos.
Formato de salida: objeto JSON.

Por qué funciona: fuerza valores normalizados para un emparejamiento fiable. Validado en GPT-4o (OpenAI), agosto de 2026.

Produce: una especificación de llamada de acción segura para reintentos para el ejecutor.

Rol: Asistente del Ejecutor
Contexto: Convertir un paso del planificador en una especificación de llamada API.
Tarea: Dado un paso del planificador, output {"endpoint","method","body","retry_policy"}.
Restricciones:
- retry_policy debe incluir "max_attempts" y "backoff_ms".
Formato de salida: JSON.

Por qué funciona: estandariza el comportamiento del ejecutor entre herramientas. Validado en Claude Opus (Anthropic), agosto de 2026.

Rol de Copy&Prompt

Copy&Prompt le ayuda a versionar, probar y recuperar paquetes de prompts y esquemas. Úselo para almacenar variantes de prompts validadas, ejecutar pruebas A/B de prompts y servir prompts canónicos en CI. Eso reduce la deriva y centraliza prompts que de otro modo quedarían en notas o chats.

Prácticamente, copie sus prompts planificador y extractor probados en Copy&Prompt con etiquetas para modelo, fecha y versión de esquema. Luego conecte el ID del prompt al ejecutor; el runtime obtiene el prompt canónico en lugar de copiar desde archivos dispersos.

Preguntas frecuentes

¿Cuál es la diferencia entre un agente y un flujo de trabajo?

Un agente es un planificador impulsado por modelo que decide las siguientes acciones. Un flujo de trabajo es una secuencia orquestada y determinista de tareas. Combínelos cuando necesite planificación más efectos secundarios garantizados; prefiera flujos puros para SLAs estrictos.

¿Cómo evito que un agente entre en bucle?

Implemente límites de iteración, exija que el planificador emita tokens "next_step", valide planes contra herramientas permitidas y añada un watchdog que detenga tras N segundos o M reintentos.

Una vez que sus flujos se ejecuten de forma reproducible, el problema pasa a ser la recuperación y la gobernanza.

Mejore sus resultados de IA hoy — Cree mejores prompts y obtenga respuestas más precisas con Copy&Prompt. Copy&Prompt →

Lecturas adicionales: OpenAI Chat Completions guide, Anthropic docs on tool use, y el curso n8n sobre patrones de integración.

Fuentes: documentación de OpenAI (platform.openai.com/docs), documentación de Anthropic (www.anthropic.com/docs), y material del curso n8n resumido para patrones de integración.