Módulo 5: ReAct, Self-Consistency y Patrones Avanzados

1. Introducción: Más Allá de Chain-of-Thought

Descripción

Chain-of-Thought (CoT) fue un salto enorme en el campo del prompt engineering: pedirle al modelo que "piense en voz alta" mejoró drásticamente su rendimiento en razonamiento matemático, lógico y multi-paso. Sin embargo, CoT tiene limitaciones fundamentales que se hacen evidentes cuando enfrentamos problemas del mundo real.

Este módulo explora cuatro técnicas avanzadas que superan esas limitaciones:

ReAct: Combina razonamiento con acciones reales (llamadas a herramientas)
Self-Consistency: Genera múltiples caminos de razonamiento y vota por consenso
Tree-of-Thought: Explora ramas de soluciones como un árbol de búsqueda
Meta-prompting & Self-Refine: Usa LLMs para optimizar y refinar sus propios prompts y respuestas

Cada técnica tiene su caso de uso ideal, su costo computacional y sus trade-offs. Al final de este módulo, tendrás un framework claro para decidir qué técnica usar en cada situación.

Las Limitaciones de Chain-of-Thought

Antes de ver las soluciones, entendamos exactamente qué falla en CoT:

1. Solo razonamiento interno

CoT solo puede "pensar" con lo que ya sabe. Si un modelo fue entrenado hasta enero de 2024, no puede saber el precio actual del petróleo, el resultado del último partido de fútbol, o el estado de un pedido en una tienda online. No hay conexión con el mundo externo.

# CoT falla aquí:
"¿Cuánto cuesta el vuelo Madrid-Nueva York hoy?"
→ El modelo inventará o dará precios desactualizados

# CoT funciona bien aquí:
"Si un tren va a 120 km/h y otro a 80 km/h..."
→ Solo necesita razonamiento matemático

2. Un único camino de razonamiento

CoT genera una sola cadena de pensamiento. Si el primer paso es erróneo, el error se propaga. No hay mecanismo de corrección ni de exploración de alternativas.

# Si el modelo asume mal en el paso 1...
Paso 1: "Asumo que X = 10" ← Error
Paso 2: "Entonces Y = X * 2 = 20" ← Propagación del error
Paso 3: "Por lo tanto Z = Y - 5 = 15" ← Respuesta incorrecta

# Con Self-Consistency, otro camino puede llegar a la respuesta correcta

3. No exploración de estrategias

Algunos problemas tienen múltiples enfoques válidos (divide y conquista, programación dinámica, búsqueda heurística). CoT elige uno implícitamente sin evaluar cuál es mejor para el problema específico.

4. Sin mecanismo de auto-corrección

CoT no tiene forma de detectar que su propia respuesta es incorrecta y corregirla. Una vez generada, es la respuesta final.

ReAct: Razonamiento + Acción

ReAct (Reasoning + Acting) fue propuesto por Yao et al. en 2022. La idea central: los LLMs deben poder interactuar con herramientas externas durante el proceso de razonamiento.

El ciclo ReAct

Thought: ¿Qué necesito saber para responder esta pregunta?
Action: search("precio petróleo hoy")
Observation: Brent crude: $78.5/barril (8 marzo 2026)
Thought: Ahora tengo el dato actual. Puedo calcular el impacto.
Action: calculator("78.5 * 0.15")
Observation: 11.775
Answer: El impuesto sería aproximadamente $11.78 por barril.

Cuándo usar ReAct

Cuando la respuesta requiere datos en tiempo real
Cuando necesitas verificar cálculos con una calculadora
Cuando debes consultar bases de datos externas
Cuando el razonamiento requiere múltiples pasos de verificación

Limitaciones de ReAct

Mayor latencia: cada Action→Observation es una llamada adicional
Mayor costo: múltiples llamadas al API
Puede entrar en loops si las herramientas no responden correctamente
Requiere implementar las herramientas (tools)

Self-Consistency: Múltiples Caminos, Una Respuesta

Self-Consistency (Wang et al., 2022) es elegantemente simple: en lugar de generar una respuesta, genera N respuestas con temperatura > 0 (para introducir variación) y luego vota por la respuesta más común.

La intuición detrás

Imagina que preguntas la misma pregunta difícil a 5 personas. Si 4 de 5 llegan al mismo resultado por caminos diferentes, es muy probable que ese resultado sea correcto.

# Con N=5 respuestas para "¿Cuánto es 15% de 480?"
Respuesta 1: "72" (Thought: 480 * 0.15 = 72)
Respuesta 2: "72" (Thought: 10% = 48, 5% = 24, total = 72)
Respuesta 3: "71" (Error de cálculo)
Respuesta 4: "72" (Thought: 480 / 100 * 15 = 72)
Respuesta 5: "72" (Thought: 72)

Majority vote: "72" ✓ (4/5 votos)

Mejora empírica típica

N	Mejora vs baseline	Costo
1	0% (baseline)	1x
3	+5-8% en math	3x
5	+8-12%	5x
10	+10-15%	10x

El punto de rendimientos decrecientes suele estar en N=5 para la mayoría de tareas.

Tree-of-Thought: Exploración de Ramas

Tree-of-Thought (ToT, Yao et al., 2023) lleva el razonamiento a otro nivel: en lugar de una cadena lineal de pensamientos, construye un árbol donde cada nodo es un estado parcial de la solución.

Estructura del árbol

                    [Problema]
                   /     |     \
               [Rama A] [Rama B] [Rama C]
               (0.7)    (0.9✓)   (0.5)
                         |
                   [Rama B1] [Rama B2]
                   (0.8✓)    (0.6)
                       |
                [Solución final]

Estrategias de búsqueda

BFS (Breadth-First): Explorar todas las ramas del mismo nivel antes de profundizar
DFS (Depth-First): Seguir la rama más prometedora hasta el final
Beam Search: Mantener las K mejores ramas en cada nivel

Cuándo usar ToT

Problemas de planificación (planning)
Puzzles con múltiples soluciones posibles
Cuando el primer enfoque de CoT frecuentemente falla
Cuando tienes presupuesto para muchas llamadas al API

Meta-Prompting y Self-Refine

Meta-prompting

El meta-prompting es usar un LLM para generar o mejorar prompts para otra tarea. En lugar de escribir manualmente el prompt perfecto, le pedimos al modelo que lo genere.

Meta-prompt:
"Crea el mejor prompt posible para: [clasificar sentimiento en reviews de restaurantes].
Considera: claridad, ejemplos, formato de salida esperado, edge cases."

→ El modelo genera un prompt optimizado
→ Usamos ese prompt para la tarea real

Self-Refine

Self-Refine (Madaan et al., 2023) implementa un ciclo de mejora iterativa:

Generate: Producir una respuesta inicial
Critique: Evaluar la respuesta en busca de errores y mejoras
Refine: Mejorar basándose en la crítica

Este proceso puede repetirse 1-3 veces antes de retornos decrecientes significativos.

Comparación de Técnicas

Técnica	Costo relativo	Latencia	Cuándo brilla
CoT	1x	Baja	Razonamiento puro
Self-Consistency (N=5)	5x	Media-Alta	Math/logic crítico
ReAct	3-10x	Alta	Datos externos
Tree-of-Thought	5-20x	Muy alta	Problemas multi-estrategia
Meta-prompting	2-3x	Media	Optimización de prompts
Self-Refine	2-4x	Media	Calidad crítica

Roadmap del Módulo 5

#	Cápsula	Tema	Lo que aprenderás
01	Introducción	Más allá de CoT	Overview de técnicas avanzadas
02	ReAct	Thought → Action → Observation	Implementar con function calling
03	Self-Consistency	N respuestas, majority vote	Sampling y voting
04	Tree-of-Thought	Exploración de ramas	BFS, DFS, evaluación
05	Meta-prompting y self-refine	Prompts que generan prompts	Ciclos de refinamiento
06	Combinación de técnicas	CoT + Self-Consistency, etc.	Combinar estrategias
07	Decision framework	Qué técnica usar	Árbol de decisión
08	Proyecto	Multi-Strategy Problem Solver	Sistema completo

Prerequisitos del Módulo

Antes de continuar, asegúrate de estar cómodo con:

Chain-of-Thought (CoT): Saber cómo escribir prompts CoT básicos
Few-shot prompting: Entender cómo los ejemplos afectan el comportamiento
OpenAI Python SDK: from openai import OpenAI, client = OpenAI()
Function calling básico: La idea de que el modelo puede "llamar funciones"

Si necesitas repasar, el Módulo 3 cubre CoT en detalle.

Primer Experimento: CoT vs Self-Refine

Para que veas la diferencia de inmediato, compara estos dos enfoques para generar un email profesional:

from openai import OpenAI

client = OpenAI()

tarea = "Escribe un email para rechazar una oferta de trabajo de forma profesional y amable."

# Enfoque 1: CoT simple (una sola generación)
response_cot = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{
        "role": "user",
        "content": f"Piensa paso a paso.\n\n{tarea}"
    }],
    temperature=0.7
)
email_cot = response_cot.choices[0].message.content

# Enfoque 2: Self-Refine (generar → criticar → mejorar)
response_draft = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": tarea}],
    temperature=0.7
)
draft = response_draft.choices[0].message.content

response_refined = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": f"""Aquí hay un borrador de email:

{draft}

Evalúa: ¿Es suficientemente profesional? ¿Es amable sin ser ambiguo?
¿Deja la puerta abierta para futuras oportunidades?
Genera una versión mejorada."""}],
    temperature=0.3
)
email_refined = response_refined.choices[0].message.content

print("=== CoT ===")
print(email_cot[:300])
print("\n=== Self-Refine ===")
print(email_refined[:300])

La versión Self-Refine cuesta 2x, pero típicamente produce emails más pulidos y equilibrados. La pregunta de ingeniería es: ¿tu caso de uso justifica ese costo?

Caso de Uso Real: Sistema de Análisis Financiero

Para dar contexto concreto, aquí hay un escenario real donde cada técnica tiene su lugar:

Sistema de análisis de reportes financieros:

1. CoT → Razonar sobre ratios financieros
2. ReAct → Buscar datos de mercado actuales
3. Self-Consistency → Validar proyecciones de ingresos
4. ToT → Explorar escenarios de inversión
5. Self-Refine → Mejorar la calidad del reporte final

No uses todas las técnicas para todo. El arte está en saber cuándo aplica cada una.

Ejercicios de Calentamiento

Ejercicio 1: Identificar limitaciones de CoT

Para cada una de las siguientes tareas, identifica si CoT puro es suficiente o si necesitarías una técnica avanzada. Justifica tu respuesta.

a) Calcular si 1337 es primo b) Determinar el precio actual de las acciones de Apple c) Resolver un acertijo lógico de Einstein d) Escribir un poema sobre el otoño e) Verificar si una fecha de entrega ya pasó (hoy es 8 marzo 2026)

Ver solución

a) CoT suficiente — Es un cálculo puro. El modelo puede razonar sobre divisibilidad sin datos externos. (Respuesta: 1337 = 7 × 191, no es primo)

b) ReAct necesario — Requiere datos en tiempo real. CoT inventaría un precio desactualizado o falso.

c) CoT suficiente (o ToT si es muy complejo) — Es razonamiento puro. Un buen prompt CoT puede resolverlo.

d) Ninguna técnica avanzada — Las tareas creativas no se benefician de CoT, ReAct o Self-Consistency. Zero-shot o few-shot es suficiente.

e) ReAct necesario — Necesita saber la fecha actual. Con CoT el modelo asumiría una fecha que podría no ser la correcta.

Ejercicio 2: Estimar costo

Si una llamada a gpt-4o-mini cuesta $0.00015 por 1K tokens de entrada y $0.00060 por 1K de salida, y cada respuesta tiene en promedio 500 tokens de entrada y 200 de salida:

¿Cuánto costaría resolver 100 problemas con:

CoT (1 llamada)
Self-Consistency N=5
ReAct con 4 pasos promedio

Ver solución

Costo por llamada ≈ 0.00015 * 0.5 + 0.00060 * 0.2 = $0.000075 + $0.000120 = $0.000195

CoT: 100 × $0.000195 = $0.0195
Self-Consistency N=5: 500 × $0.000195 = $0.0975
ReAct (4 pasos): 400 × $0.000195 = $0.078

Para 100 problemas, los costos son muy bajos. Para 100,000 problemas:

CoT: $19.5
Self-Consistency: $97.5
ReAct: $78

El costo escala linealmente, así que la elección de técnica importa a escala.

Ejercicio 3: Diseñar un workflow

Tienes un sistema de customer support que recibe tickets de usuarios. Los tickets pueden ser:

Preguntas simples ("¿Cuáles son sus horarios?")
Problemas técnicos que requieren consultar el estado de la cuenta
Quejas que requieren análisis cuidadoso antes de responder

Diseña qué técnica usarías para cada tipo de ticket y por qué.

Ver solución

Preguntas simples: Zero-shot o few-shot. No necesitas razonamiento complejo ni datos externos. Rápido y barato.

Problemas técnicos: ReAct. Necesitas consultar APIs internas (estado de cuenta, historial de pedidos, sistema de tickets). El modelo debe buscar datos reales antes de responder.

Quejas complejas: Self-Refine. Genera una respuesta inicial, luego critica el tono/contenido (¿es empática? ¿resuelve el problema?), y refina. Opcionalmente Self-Consistency si la clasificación del problema es ambigua.

Resumen

En este módulo aprenderás a ir más allá de CoT con cuatro técnicas poderosas:

ReAct: Para cuando necesitas conectarte con el mundo real (APIs, bases de datos, calculadoras). El modelo piensa → actúa → observa → repite.
Self-Consistency: Para cuando la precisión es crítica. Genera N respuestas y vota. El consenso es más confiable que una sola respuesta.
Tree-of-Thought: Para problemas complejos con múltiples estrategias. Explora ramas, evalúa, expande la mejor.
Meta-prompting y Self-Refine: Para optimizar prompts automáticamente y para mejorar iterativamente la calidad de las respuestas.

Cada técnica tiene un costo y un beneficio. El framework de decisión del módulo 07 te ayudará a elegir la correcta en cada situación.

Qué NO Cubre Este Módulo

Es importante establecer los límites para que sepas exactamente qué esperar:

Tema	¿Se cubre?	Dónde se ve
Implementación de ReAct con function calling	Sí (Cápsula 02)	Este módulo
Self-Consistency con majority vote	Sí (Cápsula 03)	Este módulo
Tree-of-Thought con BFS/DFS	Sí (Cápsula 04)	Este módulo
Meta-prompting y Self-Refine	Sí (Cápsula 05)	Este módulo
Agentes autónomos (AutoGPT, BabyAGI)	No	Fuera del scope de esta guía
Fine-tuning de modelos	No	Requiere guía dedicada de ML
Retrieval-Augmented Generation (RAG)	No	Guía de RAG separada
Entrenamiento de herramientas custom	No	Guía de Function Calling

La razón: este módulo se enfoca en técnicas de prompting que puedes aplicar hoy con cualquier modelo via API, sin necesidad de entrenar o modificar modelos. Los agentes autónomos se construyen sobre estas técnicas, pero requieren infraestructura adicional que está fuera del scope.

Preguntas Frecuentes

¿Necesito dominar CoT antes de empezar? Sí. Las técnicas de este módulo extienden CoT. Si no puedes escribir un prompt CoT que funcione consistentemente, regresa al Módulo 4 primero.

¿Puedo usar estas técnicas con modelos de código abierto? Sí. ReAct, Self-Consistency, ToT y Self-Refine funcionan con cualquier LLM que soporte chat completions. La calidad varía según la capacidad del modelo, pero las técnicas son agnósticas al proveedor.

¿Cuál es la técnica más práctica para producción? Self-Refine es probablemente la más utilizada en producción por su balance entre costo y mejora de calidad. ReAct es esencial si tu sistema necesita datos externos. Self-Consistency es ideal para tareas donde la precisión importa más que el costo.

¿Las técnicas se pueden combinar? Absolutamente. La Cápsula 06 cubre exactamente esto: CoT + Self-Consistency, ReAct + Self-Refine, etc. Las combinaciones son donde estas técnicas realmente brillan.

¿Cuánto más cuestan estas técnicas vs CoT simple? Depende de la técnica. Self-Consistency N=5 cuesta 5x. ReAct con 3-4 pasos cuesta 3-4x. Self-Refine con 2 iteraciones cuesta 3x. La tabla de comparación en esta cápsula tiene los detalles. El framework de decisión del Módulo 07 te ayuda a elegir según tu presupuesto.

Recursos adicionales

← Anterior8. Proyecto: Reasoning Engine con CoT Verificable Siguiente →2. ReAct: Reasoning + Acting