Patrones de Orquestación · Codigo Sin Siesta · 2026

Patrones de
Orquestación

10 patrones. 3 perspectivas. La misma conclusión:
la arquitectura importa más que el modelo.

A Taxonomía Evolutiva
B Por Problema
C Convergencias
Alejandro de la Fuente

Alejandro de la Fuente

Tech Lead · NTT Data · GDNE

El mapa del territorio

3 módulos. Una misma conversación.

Cada módulo es autosuficiente. Puedes usarlos juntos o por separado según la audiencia.

A Taxonomía Evolutiva

El mapa mental completo: 10 patrones en escalera ascendente de complejidad. Cada patrón existe porque el anterior tiene un límite.

Desarrolladores Arquitectos
Tesis La complejidad no es mala — tiene estructura.
B Por Problema

6 dolores reales → 6 patrones que los resuelven. No "qué es cada patrón" sino "cuándo te salva la vida cada uno".

Product Owners Tech Leads Audiencia mixta
Tesis Cada patrón nació de un pain real. El dolor es el punto de entrada.
C Convergencias

Anthropic, OpenAI, Factory y la academia llegaron independientemente a las mismas 4 conclusiones. Cuando 4 fuentes convergen, ya no es tendencia.

Arquitectos senior Decisores técnicos
Tesis No son opiniones de una empresa — son leyes emergentes del campo.

Slides 3–22 ↓

Módulo A · Taxonomía Evolutiva

La escalera de complejidad

Cada patrón existe porque el anterior tiene un límite. No son opciones paralelas — son niveles de una escalera. Subir no siempre es mejor; subir cuando lo necesitas es obligatorio.

🎯

La pregunta correcta

No "¿qué patrón uso?" sino "¿cuál es el límite del que tengo ahora y cuándo lo voy a golpear?"

📐

10 niveles, 4 capas

Desde un único agente con ReAct hasta un orquestador entrenado con RL. Cada capa añade coordinación, y coordinación tiene coste.

⚠️

El error más común

Saltarse niveles por "ambición arquitectónica". Un Orchestrator-Workers para un problema de Routing es deuda técnica disfrazada de sofisticación.

1 Single Agent ReAct
2 Reflexion
3 Pipeline
4 Routing
5 Orchestrator-Workers
6 Creator-Verifier
7 Hierarchical
8 Swarm / Mesh
9 Missions
10 Puppeteer RL
Módulo A · Niveles 1–4 · La base

El agente aprende a trabajar con otros

1 Single Agent · ReAct

Un LLM en bucle Thought → Action → Observation. La unidad mínima de agente. Razona sobre su propia acción antes de ejecutarla.

2 Reflexion

El agente genera una crítica verbal de su propio intento antes del siguiente. Sin cambiar los pesos — solo razonando sobre qué falló.

3 Pipeline Agéntico

Secuencia fija de agentes especializados: A → B → C. Topología definida antes de la ejecución. El output de cada etapa es el input de la siguiente.

4 Routing

Un clasificador inicial decide a qué agente especializado dirigir el input. Sin coordinador dinámico — la decisión es puntual y unidireccional.

Módulo A · Niveles 5–7 · Coordinación

La coordinación se hace explícita

5

Orchestrator-Workers

Un LLM central descompone la tarea, delega a workers especializados y sintetiza los resultados. La topología emerge en runtime según el input.

6

Creator-Verifier

Dos agentes con roles opuestos: uno genera, otro evalúa en contexto separado. El evaluador no tiene acceso al razonamiento del generador — solo al output.

7

Hierarchical + Broadcast

Árbol de agentes: un root-orchestrator coordina sub-orquestadores que a su vez coordinan workers. Broadcast permite notificar a múltiples ramas en paralelo.

💡

El Creator-Verifier es el patrón más subvalorado: añadir un evaluador independiente es la intervención con mejor ROI en calidad del output de cualquier sistema agéntico.

Módulo A · Niveles 8–10 · Emergencia y autonomía

Cuando los agentes se auto-organizan

8

Swarm / Mesh

Swarm: topología emergente en runtime. Los agentes se conectan dinámicamente según la tarea, como hormigas que construyen rutas sin coordinador central. Alta flexibilidad, baja predecibilidad.

Mesh: conexiones peer-to-peer fijas en design time. Cada agente conoce a sus vecinos. Más predecible que Swarm, pero con overhead de todos hablar con todos.

⚠️ Factory evita Swarm en producción: el no-determinismo hace imposible el debugging.
9

Missions (composición de 4 patrones)

El patrón de Factory para tareas de software de semanas de duración. Combina: Orchestrator-Workers (3 roles) + Creator-Verifier (Validation Contracts) + ejecución serial (sin merge conflicts) + Handoffs estructurados (5 campos). Dato de producción: Slack clone en 16.5h, 778M tokens, 89% test coverage.

✓ Comprobado en producción. La anti-fragilidad viene de lógica en prompts, no en código.
10

Puppeteer / RL Orchestration

Un orquestador entrenado con Reinforcement Learning que aprende qué secuencia de delegaciones produce mejores resultados. Las 5 sub-decisiones que aprende: cuándo spawnear, a quién delegar, cómo comunicar, cómo agregar, cuándo parar.

🔬 Investigación de frontera. Mayo 2026: sin método publicado para la decisión de cuándo parar.
Módulo A · Las 4 capas de complejidad

El mapa completo

CAPA 4 · AUTONOMÍA APRENDIDA
10 Puppeteer / RL
El orquestador aprende de la historia de ejecución
CAPA 3 · COORDINACIÓN COMPLEJA
7 Hierarchical
8 Swarm
8 Mesh
9 Missions
Multi-nivel · topología flexible o fija
CAPA 2 · COORDINACIÓN BÁSICA
5 Orchestrator-Workers
6 Creator-Verifier
Un coordinador, múltiples workers o evaluadores
CAPA 1 · AGENTE SIMPLE
1 ReAct
2 Reflexion
3 Pipeline
4 Routing
Topología fija · sin coordinador dinámico
Complejidad · Coordinación · Coste

Regla de oro: usa la capa más baja que resuelve tu problema. Cada capa añade overhead de coordinación que no se recupera si no lo necesitas.

Módulo B · Por Problema que Resuelven

Cada patrón nació de un dolor real

En lugar de preguntar "¿qué es este patrón?", pregunta "¿cuándo te salva la vida?". El pain es el punto de entrada más honesto a la arquitectura.

🪞 1 El agente no detecta sus propios errores
💧 2 El contexto se degrada en tareas largas
⚔️ 3 Los agentes en paralelo se pisan los cambios
🐛 4 Los tests no atrapan bugs reales
🦕 5 El sistema queda obsoleto con cada modelo
🔭 6 Supervisar sin microgestionar
Problema 1 🪞

El agente no detecta sus propios errores

El dolor

Un agente que genera código, lo prueba con tests que él mismo escribió y lo declara correcto está cerrando el bucle sobre sí mismo. Confirmation bias a escala de máquina: el evaluador tiene el mismo punto ciego que el generador.

Agente A: genera función + tests
Agente A: ejecuta tests → ✅ pass
Producción: 💥 falla en edge case no contemplado

El patrón: Creator-Verifier

CREATOR genera código · no ve el plan del evaluador
VERIFIER contexto separado · evalúa solo el output

Por qué funciona: el evaluador no tiene acceso al razonamiento del generador. Sus puntos ciegos son diferentes. La intersección de los dos errores es mucho menor que el error individual.

Anthropic lo llama "Generator-Evaluator" · Factory: "Worker-Validator" · misma idea, mismo resultado
Problema 2 💧

El contexto se degrada en tareas largas

El dolor

Un agente que trabaja días en la misma sesión acumula ruido en su context window. Los resultados parciales de hace 50 pasos compiten con las instrucciones actuales. La calidad del razonamiento cae de forma no lineal a medida que el contexto crece.

Turno 1
95%
Turno 10
80%
Turno 50
55%
Turno 200
30%

Calidad de razonamiento estimada (degradación acumulativa)

El patrón: Context Isolation + Structured Handoffs

Worker A contexto propio · 0 ruido externo
handoff estructurado
Worker B recibe solo lo necesario · contexto fresco

Los 5 campos del handoff (Factory)

objetivo_completado
estado_actual_sistema
decisiones_tecnicas_tomadas
proximos_pasos
contexto_critico

El handoff no es un resumen informal — es un contrato. El worker siguiente puede arrancar desde 0 con solo esos 5 campos. La misión puede durar semanas.

Problema 3 ⚔️

Los agentes en paralelo se pisan los cambios

El dolor

Correr 10 agentes en paralelo escribiendo código parece la solución obvia para acelerar. El resultado real: merge conflicts, estados inconsistentes, linter que pasa en aislamiento pero falla en integración.

Agente A escribe auth.ts
Agente B escribe auth.ts
Agente C escribe user.ts
↓ integración
💥 conflicts · estado inconsistente · debugging imposible

Factory midió esto: el overhead de coordinación de agentes paralelos sobre el mismo codebase supera el beneficio de velocidad en la mayoría de tareas de software.

El patrón: Serial con paralelismo interno read-only

📋

Orchestrator planifica

descompone en tareas seriales sin solapamiento

⚙️

Worker 1 implementa módulo A

acceso exclusivo de escritura · paralelismo solo en lectura

Validator verifica

tests · lint · code review (pueden correr en paralelo)

⚙️

Worker 2 implementa módulo B

parte del estado validado del worker 1

El paralelismo es seguro cuando los agentes solo leen. Los validadores (tests, lint, reviews) pueden correr en paralelo porque no modifican el estado.

Problema 4 🐛

Los tests escritos por el mismo agente no atrapan bugs reales

El dolor

Si el mismo agente que implementa también escribe los tests, ambos parten del mismo malentendido. El agente no tiene un spec externo — tiene su propia interpretación de lo que debería hacer el código. Los tests validan esa interpretación, no el comportamiento correcto.

52% de los tests en la misión Slack clone los escribió el mismo worker que implementó
89% coverage final — gracias al Validation Contract escrito antes de la implementación

El patrón: Validation Contract

ANTES de implementar

Validation Contract

✓ Criterios de aceptación funcional

✓ Casos edge obligatorios

✓ Performance thresholds

✓ Constraints de seguridad

↓ Worker implementa contra este contrato
DESPUÉS de implementar

Scrutiny Validator (pipeline)

→ Tests contra el contrato

→ Linter + type-check

→ Code review agente independiente

El contrato lo escribe el Orchestrator, que tiene la visión de la tarea completa. El Worker no puede alterar los criterios de aceptación.

Problema 5 🦕

El sistema queda obsoleto con cada nuevo modelo

El dolor

Si tu lógica de orquestación está hardcodeada en una state machine — "si output contiene X, haz Y, sino Z" — tienes que reescribirla cada vez que cambias de modelo. El modelo mejora sus capacidades y tu código no sabe aprovecharlo.

Orquestación frágil (state machine)

if (output.includes('error')) {
  retryStrategy = 'exponential';
} else if (confidence < 0.7) {
  escalate('human');  // hardcoded threshold
}

Cuando GPT-5 / Claude 5 salgan, estos thresholds son basura.

El patrón: lógica en prompts (Factor 8)

Orquestación anti-frágil (lógica en texto)

"Si detectas que la implementación tiene baja cobertura de edge cases, genera tests adicionales antes de marcar la tarea como completa. Si encuentras un error de compilación, intenta corregirlo hasta 3 veces antes de escalar al orchestrator."

Un modelo mejor entiende mejor estas instrucciones. No hay código que actualizar.

📝

Las Missions de Factory: ~700 líneas de texto

La lógica del orquestador está en prompts, no en código. Cada release de modelo la mejora gratis.

🔧

12-factor agents, Factor 8

"Codifica la lógica de negocio en prompts, no en state machines. El modelo es el intérprete."

Problema 6 🔭

Supervisar a los agentes sin microgestionar

El dolor

El pendulo oscila entre dos extremos igual de malos: aprobar cada acción (el agente pierde todo su valor) o no supervisar nada (el agente causa daños antes de que alguien los vea).

Sin supervisión
Micro-gestión
Daños antes de detectar Agente inútil

La solución no es un punto fijo en el espectro — es supervisión dinámica orientada a riesgo.

El patrón: HITL/HOTL + Mission Control

Automatización completa Bajo riesgo

tests, lint, formatting, operaciones de lectura

Human-on-the-Loop Riesgo medio

commits, PRs, mensajes a usuarios, deploys a staging

Human-in-the-Loop Alto riesgo

producción, datos sensibles, acciones irreversibles

Marco de decisión rápida

¿Es irreversible? → HITL obligatorio
¿Afecta a terceros? → HITL o HOTL según regulación
¿Cuánto daño si se equivoca? → proporcional al nivel de supervisión

EU AI Act, Art. 14: supervisión humana obligatoria para sistemas IA de alto riesgo.

Módulo C · Convergencias Industria

4 fuentes independientes. Las mismas conclusiones.

Cuando una empresa hace una afirmación sobre IA, es una opinión. Cuando 4 fuentes que no se coordinaron llegan a lo mismo, empieza a ser una ley del campo.

Anthropic Engineering

Generator-Evaluator · 12-factor agents · Sprint Contracts

OpenAI / Lopopolo

Harness Engineering · PNPM 750 packages · Persona-based reviewers

Factory (Missions)

Orchestrator-Workers-Validators · Validation Contracts · 16.5h Slack clone

Academia (Tsinghua / Stanford)

NLAH +16.8pts · Meta-Harness 6× variance · GRPO multi-agent

Las 4 convergencias que emergen:

1 Harness > Modelo
2 Separar generación y evaluación
3 Lógica en prompts, no en estado
4 Estado externalizado y estructurado
Convergencia 1

Harness > Modelo

La arquitectura que envuelve al LLM determina más el rendimiento que el modelo en sí.

NLAH · Tsinghua 2026
+16.8 puntos de accuracy

Solo cambiando la representación del harness (código → lenguaje natural). Mismo modelo, misma tarea.

Meta-Harness · Stanford 2026
6× más varianza explicada

La arquitectura del harness explica 6 veces más la variación en rendimiento que la elección del modelo.

Factory Missions 2025
16 días → 16.5 horas

Slack clone completo. 778M tokens, 89% test coverage. El harness define el patrón de éxito.

Lopopolo · OpenAI 2026
"Toda interacción es fallo del harness"

Si el agente necesita clarificación humana, el harness no dio suficiente contexto. El problema es siempre la estructura.

Implicación práctica: la decisión de qué modelo usar es secundaria a la decisión de cómo estructurar el harness. Invierte más tiempo en la arquitectura que en el benchmark.

Convergencia 2

Separar generación y evaluación

Tres empresas con tres nombres distintos para el mismo principio — señal de convergencia real.

Anthropic
Generator + Evaluator

El evaluador opera en contexto separado. No ve el razonamiento del generador — solo su output. Sesgo independiente es el objetivo.

Sprint Contracts definen los criterios de evaluación antes de que el generador empiece.
OpenAI / Lopopolo
Persona-based Reviewer Agents

Agentes reviewer con personalidades distintas (el escéptico, el optimizador de rendimiento, el de seguridad). Diferentes ángulos de ataque.

Code review en CI: no opcional, parte del harness. Cada revisión es autónoma.
Factory
Worker + Validator + Scrutiny Validator

Dos tipos de validación: el Validator evalúa contra el Validation Contract; el Scrutiny Validator ejecuta el pipeline (tests → lint → type-check → review).

El Orchestrator decide si el output pasa a la siguiente tarea o se reprocesa.
🧠

Por qué funciona: los LLMs tienen confirmation bias. Un modelo que genera también tiene el sesgo de "esto parece correcto porque yo lo generé". El evaluador independiente rompe ese ciclo.

Convergencia 3

Lógica en prompts, no en estado

Un sistema frágil requiere reescritura con cada nuevo modelo. Un sistema anti-frágil mejora solo.

Sistema frágil

// Orchestrator hardcodeado

if (confidence < 0.75) {

retry(3);

} else if (error_type == 'auth') {

escalate('human');

}

❌ Claude 5 sube baseline → thresholds son incorrectos

❌ Nueva categoría de error → reescribir código

❌ Cada release de modelo requiere QA completo

Sistema anti-frágil

"Si el resultado no cumple los criterios del Validation Contract, genera una descripción específica de por qué falló y reintenta con ese contexto. Si tras 3 intentos no converge, escala al orchestrator con un análisis de la causa raíz."

✓ Claude 5 entiende mejor estas instrucciones → mejora gratis

✓ Nueva situación → el modelo la maneja con razonamiento

✓ Sin código que actualizar con cada release

Factory Missions ~700 líneas de texto de lógica de orquestador
12-factor agents (Factor 8) "El modelo es el intérprete, no el estado"
NLAH (Tsinghua) Execution contracts en lenguaje natural → +16.8pts
Convergencia 4

Estado externalizado y estructurado

Si el estado vive solo en el context window, el agente no puede trabajar más de unas horas. Si vive fuera, puede trabajar semanas.

Factory Missions Semanas de ejecución
Structured Handoffs

5 campos JSON en el handoff. El estado del sistema en un formato que cualquier worker puede consumir sin el contexto histórico.

NLAH (Tsinghua) Días de ejecución
File-backed State

El estado de la misión se persiste en archivos. Si el agente se reinicia, recupera exactamente donde estaba. Sin perder progreso.

BettaTech Harness Proyectos largos
Carpeta progress/ compartida

Los agentes leen y escriben en progress/ como memoria externalizada. El contexto window del agente es efímero; el estado no.

Lopopolo / OpenAI Proyectos multi-semana
Git como memoria

El historial de git es el estado externalizado. El agente puede "recordar" decisiones pasadas leyendo commits, sin que ese contexto esté en su ventana.

📦

El principio

El context window es RAM — efímero y limitado. El estado externalizado es disco — persistente y sin límite de tamaño. Los sistemas agénticos de larga duración usan el context window como buffer de trabajo, no como almacén de estado.

Módulo C · Matriz de convergencias

La misma conclusión, 4 veces

Convergencia
Anthropic
OpenAI / Lopopolo
Factory
Academia
Harness > Modelo
Generator-Evaluator, Sprint Contracts
Harness Engineering keynote, "toda interacción es fallo del harness"
Missions: 16.5h Slack clone, droid whispering
NLAH +16.8pts, Meta-Harness 6×
Separar Gen/Eval
Generator + Evaluator en contextos separados
Persona-based reviewer agents, code review en CI
Worker + Validator + Scrutiny Validator
Multi-agent GRPO: roles separados en entrenamiento
Lógica en prompts
Factor 8 de 12-factor agents
Skills ricas sobre proliferación de código
~700 líneas de texto de orquestador, anti-fragilidad
NLAH: execution contracts en lenguaje natural
Estado externalizado
Checkpointing, handoffs estructurados
Git como memoria, 750 packages PNPM como contexto
Structured Handoffs 5 campos, misiones de semanas
File-backed state (NLAH), progress/ compartida
🎯

Cuando Anthropic, OpenAI, Factory y la academia llegan independientemente a las mismas 4 conclusiones, dejan de ser recomendaciones y se convierten en restricciones del dominio. No seguirlas no es heterodoxia — es ignorancia.

Lo que se lleva el que estuvo en la sala

01 Módulo A

La escalera no se puede saltarse

Cada nivel de complejidad existe porque el anterior tiene un límite real. Saltar niveles por ambición arquitectónica produce deuda técnica disfrazada de sofisticación.

02 Módulo B

El evaluador independiente es tu mejor inversión

Un agente que valida su propio trabajo tiene confirmation bias. Añadir un evaluador en contexto separado es la intervención con mejor ROI en calidad del sistema.

03 Módulo B+C

Lógica en texto, estado fuera del contexto

La lógica de orquestación en prompts mejora con cada nuevo modelo sin tocar código. El estado en disco permite misiones de semanas. Estos dos principios juntos definen la anti-fragilidad.

04 Módulo C

Anthropic, OpenAI, Factory y academia dicen lo mismo

Las 4 convergencias no son tendencias — son restricciones emergentes del campo. El harness explica más varianza que el modelo. Invertir en arquitectura antes que en benchmarks.

Estos no son patrones de moda. Son respuestas ingenieriles a problemas concretos que aparecen siempre que un agente trabaja en tareas no triviales. El contexto cambia; el problema no.

1 / 22
Navegación