Cuando construyes un agente de IA tienes que decidir cómo controla su propio trabajo, y casi siempre eliges entre dos patrones: ReAct, que decide un paso cada vez razonando y actuando en bucle, y plan-and-execute, que traza primero un plan completo y luego lo ejecuta paso a paso. No hay un ganador absoluto: ReAct se adapta mejor a lo imprevisto, mientras que plan-and-execute gasta menos llamadas al modelo grande y ordena mejor las tareas largas. En esta guía verás cómo funciona cada uno, cuándo conviene cada patrón y qué enfoques híbridos combinan lo mejor de ambos. La misma explicación está disponible en inglés.

Puntos clave

  • ReAct (razonar y actuar, del artículo de Yao y sus colegas, arXiv 2210.03629[1], ICLR 2023) intercala pensamiento, acción y observación en un solo bucle: el modelo decide el paso siguiente solo después de ver el resultado del anterior.
  • Plan-and-execute separa un planificador, que traza todos los pasos por adelantado, de un ejecutor que los realiza uno a uno sin volver a consultar al modelo grande en cada acción.
  • El coste y la latencia son la gran diferencia: plan-and-execute evita una llamada al modelo planificador por cada herramienta; la variante LLMCompiler mide hasta 3,7 veces menos latencia, hasta 6,7 veces menos coste y hasta un 9 % más de acierto frente a ReAct.
  • ReAct sigue ganando en tareas exploratorias donde no se conoce el camino de antemano y hay que adaptarse a cada observación.
  • Los enfoques híbridos (replanificación tras cada bloque, ReWOO, LLMCompiler) son hoy la práctica más habitual: planificar por adelantado y revisar el plan cuando algo falla.

Los dos patrones de control agéntico

Todo agente resuelve una tarea encadenando llamadas al modelo y a herramientas, pero se diferencian en quién decide el paso siguiente y cuándo. Ese detalle define el patrón de control, y en 2026 el debate práctico se reduce a dos familias.

El primero es ReAct, abreviatura de reasoning and acting (razonar y actuar). Es el corazón del bucle agéntico y del patrón ReAct: el modelo genera un pensamiento, elige una acción (por ejemplo, llamar a una herramienta), observa el resultado y vuelve a empezar. Cada iteración parte de lo que acaba de aprender, así que el agente improvisa el plan sobre la marcha.

El segundo es plan-and-execute (planificar y ejecutar). Aquí el agente primero se detiene a pensar la tarea entera y produce un plan explícito con todos los pasos; después un ejecutor los va cumpliendo en orden. La idea entronca con la planificación y descomposición de tareas y con el artículo de Plan-and-Solve prompting (Wang y sus colegas, arXiv 2305.04091[2], ACL 2023), que demostró que pedir al modelo un plan antes de resolver «supera de forma consistente al zero-shot chain-of-thought en todos los conjuntos de datos por un margen amplio».

¿Cómo funciona plan-and-execute?

El patrón plan-and-execute tiene tres piezas: un planificador, un ejecutor y, casi siempre, un paso de replanificación. El planificador recibe el objetivo y devuelve una lista ordenada de subtareas. El ejecutor toma la primera, la resuelve (llamando a una herramienta o a un modelo más pequeño) y guarda el resultado; luego pasa a la siguiente. Cuando termina el plan, o cuando un paso falla, se vuelve a llamar al planificador para cerrar la tarea o corregir el rumbo.

La diferencia clave frente a ReAct está en cuántas veces interviene el modelo caro. En ReAct, el modelo grande decide en cada iteración; en plan-and-execute, el modelo grande interviene sobre todo al planificar y al replanificar, mientras la ejecución de cada paso puede recaer en un modelo más ligero. Este esqueleto en pseudocódigo resume ambos bucles:

# ReAct: una decisión por paso, siempre con el modelo grande
estado = objetivo
while not terminado:
    pensamiento, accion = modelo_grande(estado)   # 1 llamada cara por paso
    observacion = ejecutar(accion)
    estado = estado + observacion

  # Plan-and-execute: planificar una vez, ejecutar barato
plan = modelo_grande(objetivo)                     # 1 llamada cara: traza N pasos
for paso in plan:
    resultado = modelo_ligero(paso)                # ejecucion barata por paso
    if fallo(resultado):
        plan = modelo_grande(objetivo, resultados) # replanificar solo si hace falta

Las variantes más conocidas refinan esta idea. ReWOO (razonar sin observar) hace que el plan use variables como #E1 o #E2 para encadenar resultados sin volver a llamar al modelo entre paso y paso. LLMCompiler va más allá: convierte el plan en un grafo de tareas y las ejecuta en paralelo cuando no dependen unas de otras.

Ventajas: menos llamadas, menor coste y mejor planificación

La ventaja más tangible es económica. Como el ejecutor no consulta al modelo grande en cada acción, plan-and-execute reduce el número de llamadas caras y la latencia acumulada. La documentación de LangChain lo resume así: estos agentes «no necesitan llamar al gran modelo planificador en cada invocación de herramienta», y permiten reservar el modelo potente para planificar y usar modelos más pequeños en la ejecución.

Los números lo respaldan. El artículo de LLMCompiler (arXiv 2312.04511[3]) mide, frente a un agente ReAct equivalente, hasta 3,7 veces menos latencia, hasta 6,7 veces menos coste y hasta un 9 % más de acierto, gracias a planificar por adelantado y ejecutar en paralelo. La segunda ventaja es la calidad del plan: obligar al modelo a pensar la tarea entera antes de empezar reduce el riesgo de que se pierda a mitad de camino, un fallo típico de los agentes que solo miran un paso.

Hay un matiz importante. Anthropic advierte en Building Effective Agents[4] que «los sistemas agénticos suelen cambiar latencia y coste por un mejor rendimiento en la tarea», y recomienda empezar por lo más simple y añadir complejidad solo cuando aporta de verdad. Plan-and-execute encaja bien cuando la tarea es larga y su forma es previsible; para algo corto, montar un planificador aparte es más maquinaria de la necesaria.

¿Cuándo sigue siendo mejor ReAct?

ReAct brilla precisamente donde plan-and-execute sufre: en tareas abiertas cuyo camino no se conoce de antemano. Si el siguiente paso depende de lo que descubras en el anterior (buscar en la web, leer un archivo, consultar una API y decidir según la respuesta), un plan fijado al principio se queda obsoleto enseguida. ReAct, al decidir con la observación fresca en la mano, se adapta sin fricción.

También es más simple de construir y de depurar. Un solo bucle de razonar, actuar y observar es fácil de instrumentar y de entender cuando algo va mal, mientras que separar planificador y ejecutor añade piezas y puntos de fallo. Para muchos agentes de tamaño medio, un ReAct bien hecho basta, y esa simplicidad es justo lo que Anthropic aconseja no abandonar sin motivo.

Esta es la comparación rápida entre ambos patrones:

Criterio ReAct Plan-and-execute
Cuándo decide Un paso cada vez, tras cada observación Todo el plan por adelantado
Llamadas al modelo grande Una por paso Una al planificar (más replanificaciones)
Coste y latencia Más altos en tareas largas Más bajos: hasta 6,7 veces menos coste (LLMCompiler)
Adaptación a lo imprevisto Alta Baja sin replanificación
Complejidad de implementación Baja (un bucle) Media (planificador y ejecutor separados)

Enfoques híbridos: replanificación y ejecución en paralelo

En la práctica, casi nadie elige uno de los dos en su forma pura. El patrón dominante es plan-and-execute con replanificación: el agente traza un plan, ejecuta un bloque de pasos y luego vuelve a llamar al planificador con los resultados para ajustar lo que queda. Así conserva la eficiencia de planificar por adelantado y recupera parte de la adaptación de ReAct.

Los frameworks modernos ofrecen ambos patrones como piezas intercambiables. El OpenAI Agents SDK, por ejemplo, te deja construir un agente ReAct clásico o encadenar un agente planificador con agentes ejecutores mediante handoffs. La recomendación práctica es empezar con ReAct por su simplicidad y migrar hacia plan-and-execute (o un híbrido con replanificación) solo cuando midas que las tareas son lo bastante largas y repetitivas como para que el ahorro de llamadas compense la complejidad añadida.

Preguntas frecuentes

¿Plan-and-execute es siempre más barato que ReAct?

No siempre, pero suele serlo en tareas de varios pasos. El ahorro viene de no llamar al modelo grande en cada acción y de poder usar un modelo más pequeño en la ejecución; el artículo de LLMCompiler mide hasta 6,7 veces menos coste frente a ReAct. En tareas de uno o dos pasos, en cambio, montar un planificador aparte añade una llamada extra sin beneficio, así que ReAct resulta igual de eficiente y más simple.

¿Puedo combinar los dos patrones?

Sí, y es lo más recomendable. El híbrido habitual es plan-and-execute con replanificación: planificas por adelantado, ejecutas un bloque de pasos y vuelves a planificar con los resultados en la mano. Variantes como ReWOO y LLMCompiler llevan esta idea más lejos con variables de referencia y ejecución en paralelo, combinando el orden de la planificación con la capacidad de reaccionar de ReAct.

¿Cuál debería usar para empezar?

Empieza con ReAct. Es un único bucle de razonar, actuar y observar, fácil de construir y de depurar, y cubre bien la mayoría de agentes de tamaño medio. Migra a plan-and-execute cuando notes que tus tareas son largas, con pasos previsibles, y que el coste de las llamadas repetidas al modelo grande empieza a pesar. Anthropic aconseja justo eso: partir de lo simple y añadir complejidad solo cuando aporta de verdad.

Conclusión

ReAct y plan-and-execute no son rivales, sino dos herramientas para problemas distintos. ReAct decide paso a paso y se adapta a lo imprevisto con un solo bucle sencillo; plan-and-execute planifica por adelantado, gasta menos llamadas al modelo caro y ordena mejor las tareas largas, a cambio de más maquinaria. La elección madura casi siempre es un híbrido: planificar cuando la tarea lo permite y replanificar cuando la realidad cambia. El siguiente paso es probar ambos sobre una misma tarea en tu framework favorito, como el OpenAI Agents SDK, y medir coste y aciertos antes de decidir.

Fuentes: [1] Plan-and-Solve Prompting, arXiv 2305.04091[2], [2] Plan-and-Execute Agents, blog de LangChain[5], [3] Building Effective Agents, Anthropic[4], [4] ReAct, arXiv 2210.03629[1], [5] An LLM Compiler for Parallel Function Calling, arXiv 2312.04511[3].

Visitas: 1

Fuentes

  1. arXiv 2210.03629
  2. arXiv 2305.04091
  3. arXiv 2312.04511
  4. Building Effective Agents
  5. Plan-and-Execute Agents, blog de LangChain

Ruta: Fundamentos de los agentes de IA