Los 5 patrones de arquitectura de workflow de IA

La mayoría de los sistemas de IA en producción no son agentes libres que deciden todo en tiempo real. Son workflows estructurados que combinan modelos de lenguaje con lógica de control explícita.

Detrás de esa diversidad hay solo 5 patrones fundamentales. Entenderlos es entender cómo se construyen sistemas de IA robustos.

Por qué los patrones importan

Un workflow de IA es una secuencia de pasos donde algunos pasos involucran un modelo de lenguaje y otros son lógica de programación convencional. La diferencia con un agente es que el flujo está definido explícitamente: sabes de antemano qué pasos existen y en qué orden se ejecutan.

Los patrones son las estructuras de control que organizan esos pasos. Igual que en programación usas bucles, condicionales y funciones, en workflows de IA usas estos 5 patrones.

Patrón 1: Pipeline secuencial

Descripción: Los pasos se ejecutan uno tras otro, donde el output de cada paso es el input del siguiente.

Input → Paso A → Paso B → Paso C → Output

Cuándo usarlo: Cuando la tarea tiene etapas claramente diferenciadas y cada una depende de la anterior.

Ejemplo: Pipeline de generación de contenido

1. Extrae los puntos clave del brief (LLM)
2. Genera el borrador basado en los puntos clave (LLM)
3. Revisa el borrador contra la guía de estilo (LLM)
4. Formatea el resultado final (código)

Por qué dividir en pasos: Un solo prompt que intente hacer todo esto a la vez genera resultados más inconsistentes. Dividir permite controlar cada etapa, añadir validaciones entre pasos y reintentar etapas específicas si fallan.

Implementación básica:

def pipeline(brief: str) -> str:
    puntos = extraer_puntos(brief)          # LLM call 1
    borrador = generar_borrador(puntos)      # LLM call 2
    revisado = revisar_estilo(borrador)      # LLM call 3
    return formatear(revisado)               # no LLM

Ventajas: Simple, predecible, fácil de depurar. Limitaciones: Tan lento como el paso más lento; los errores se propagan.

Patrón 2: Ejecución en paralelo

Descripción: Varios pasos se ejecutan simultáneamente y los resultados se combinan.

         ┌→ Paso A ─┐
Input →  ├→ Paso B ─┼→ Combinar → Output
         └→ Paso C ─┘

Cuándo usarlo: Cuando tienes subtareas independientes que no dependen entre sí.

Ejemplo: Análisis de producto multi-perspectiva

• Simultáneamente: analiza aspectos técnicos + analiza precio/competencia + analiza perfil de usuario
• Combina los tres análisis en un informe

Por qué es valioso: Reduce el tiempo de respuesta cuando tienes múltiples subtareas independientes. Un análisis que llevaría 15 segundos en secuencia puede completarse en 5 segundos en paralelo.

Implementación con asyncio (Python):

async def analisis_paralelo(producto: str) -> dict:
    tecnico, precio, usuario = await asyncio.gather(
        analizar_aspectos_tecnicos(producto),
        analizar_precio_competencia(producto),
        analizar_perfil_usuario(producto),
    )
    return combinar_analisis(tecnico, precio, usuario)

Variante: Map-Reduce — Aplica el mismo paso a múltiples inputs en paralelo, luego reduce los resultados:

[doc1, doc2, doc3] → [summarize(doc1), summarize(doc2), summarize(doc3)] → combine_summaries()

Ventajas: Reduce la latencia total, aprovecha la concurrencia de las APIs. Limitaciones: Los costes se multiplican; requiere lógica de combinación.

Patrón 3: Ramificación condicional

Descripción: El flujo toma caminos distintos según el resultado de una clasificación.

Input → Clasificar → [condición A] → Proceso A → Output
                  → [condición B] → Proceso B → Output
                  → [condición C] → Proceso C → Output

Cuándo usarlo: Cuando diferentes tipos de inputs requieren tratamientos distintos.

Ejemplo: Router de soporte al cliente

1. Clasifica la consulta (LLM o clasificador ligero): técnica / facturación / general / escalable
2. Según la categoría: responde con la base de conocimiento correspondiente, o escala a humano

Ejemplo real de routing por complejidad:

def procesar_consulta(consulta: str) -> str:
    categoria = clasificar(consulta)  # "simple" | "compleja" | "escalar"

    if categoria == "simple":
        return responder_con_haiku(consulta)      # modelo barato
    elif categoria == "compleja":
        return responder_con_sonnet(consulta)     # modelo potente
    else:
        return escalar_a_humano(consulta)         # sin LLM

Este patrón es la base del LLM routing: usar el modelo más barato que puede resolver cada tipo de tarea.

Ventajas: Eficiencia de costes, especialización por caso de uso. Limitaciones: La calidad del clasificador determina la calidad del sistema.

Patrón 4: Bucle con criterio de salida

Descripción: Un paso se ejecuta repetidamente hasta que se cumple un criterio de calidad o se alcanza un límite de iteraciones.

Input → Proceso → ¿Criterio cumplido? → Sí → Output
                ↑         ↓ No
                └─ Refinar ──┘

Cuándo usarlo: Cuando la calidad del output puede mejorarse iterativamente.

Variante más común: Critic-Refine

1. Genera un borrador (LLM)
2. Un "crítico" evalúa el borrador (LLM, mismo o diferente)
3. Si el crítico aprueba → salir. Si no → refinar y volver a 2.

MAX_ITERACIONES = 3

def generar_con_refinamiento(brief: str) -> str:
    borrador = generar(brief)

    for _ in range(MAX_ITERACIONES):
        evaluacion = evaluar_calidad(borrador)
        if evaluacion.aprobado:
            break
        borrador = refinar(borrador, evaluacion.sugerencias)

    return borrador

El límite de iteraciones es obligatorio: Sin él, un bucle puede ejecutarse indefinidamente con costes descontrolados.

Variante: Self-correction — El modelo evalúa su propio output con un segundo prompt de verificación antes de devolver el resultado.

Ventajas: Puede producir outputs de alta calidad que una sola pasada no conseguiría. Limitaciones: Coste y latencia se multiplican; el crítico puede no ser fiable.

Patrón 5: Human-in-the-loop

Descripción: El workflow pausa en puntos específicos para obtener validación o input humano antes de continuar.

Input → Proceso A → ⏸ Revisión humana → [aprobado] → Proceso B → Output
                                       → [rechazado] → Proceso A (con feedback)

Cuándo usarlo: Cuando una decisión o acción tiene consecuencias irreversibles o alto riesgo.

Ejemplo: Workflow de publicación de contenido

1. Genera el artículo (LLM)
2. ⏸ El editor revisa y aprueba/edita
3. Si aprobado: publica en el CMS
4. Si rechazado: regenera con el feedback del editor

Ejemplo: Workflow de compras automatizadas

1. Identifica el proveedor óptimo y el precio (LLM + búsqueda)
2. Genera el borrador del pedido
3. ⏸ Aprobación humana para pedidos > 1.000€
4. Ejecuta la compra

Implementación: Requiere persistencia del estado del workflow entre la pausa y la reanudación. Herramientas como LangGraph tienen primitivas específicas para esto (interrupts).

Ventajas: Mitiga el riesgo de acciones incorrectas, mantiene supervisión humana donde importa. Limitaciones: Introduce latencia; requiere que haya alguien disponible para revisar.

Cómo se combinan los patrones

Los sistemas reales combinan varios patrones. Un workflow típico de procesamiento de documentos podría verse así:

[Lista de docs] → Paralelo (resumir cada doc)
               → Secuencial: [combinar resúmenes] → [generar informe]
               → Condicional: ¿informe > 2000 palabras?
                              → Sí: reducir
                              → No: publicar directamente
               → Human-in-the-loop: aprobación final antes de enviar

Elegir el patrón correcto

| Pregunta | Si sí → usar | |----------|-------------| | ¿Los pasos dependen secuencialmente entre sí? | Pipeline secuencial | | ¿Hay subtareas que no dependen entre sí? | Paralelo | | ¿Distintos inputs necesitan procesos distintos? | Condicional | | ¿El output puede mejorarse iterativamente? | Bucle | | ¿Hay decisiones de alto riesgo o irreversibles? | Human-in-the-loop |

La mayoría de los sistemas de producción son combinaciones de estos 5. Empezar con el patrón más simple que resuelve el problema y añadir complejidad solo cuando hay evidencia de que la necesitas.

---

Recursos relacionados:

• Qué son los workflows de IA — fundamentos antes de los patrones
• Cómo construir un workflow de IA en producción — implementación práctica paso a paso
• LLM routing — el patrón condicional aplicado a selección de modelos
• Biblioteca de workflows — plantillas de workflows listos para usar