El patrón de reflexión es la técnica que hace que un agente revise su propio trabajo antes de darlo por bueno. En lugar de responder de un tirón, el agente genera una primera versión, la critica como lo haría un revisor y la reescribe teniendo en cuenta esa crítica, a veces en varias rondas. En esta guía verás qué es la reflexión, cómo se implementa con un bucle de generación y crítica, qué proponen los dos artículos que la popularizaron (Reflexion y Self-Refine), cuándo mejora de verdad los resultados y cuánto cuesta en tokens y latencia. La misma explicación está disponible en inglés.

Puntos clave

  • La reflexión es un patrón de diseño en el que el propio modelo evalúa su salida y la corrige, sin cambiar sus pesos ni reentrenar.
  • Reflexion (arXiv 2303.11366[1], marzo de 2023) introdujo el refuerzo verbal: el agente escribe una reflexión sobre su error y la guarda en memoria para el siguiente intento; alcanzó un 91 % de aciertos (pass@1) en HumanEval, frente al 80 % de GPT-4.
  • Self-Refine (arXiv 2303.17651[2], 2023) usa un solo modelo como generador, crítico y corrector, y logró una mejora absoluta media cercana al 20 % en siete tareas.
  • Anthropic llama a este flujo evaluador-optimizador y advierte de que solo compensa cuando hay criterios de evaluación claros y la iteración aporta una mejora medible.
  • Reflejar tiene coste: cada ronda añade al menos dos llamadas más al modelo, así que puede multiplicar por tres o más los tokens y la latencia de una respuesta.

¿Qué es la reflexión en un agente de IA?

La reflexión es un patrón de diseño agéntico en el que el modelo examina su propia salida, detecta problemas y produce una versión mejor. Se apoya en una observación empírica: un modelo de lenguaje suele ser mejor juzgando una respuesta que generándola a la primera. Pedirle "revisa este código y señala los fallos" activa un razonamiento distinto al de "escribe este código", y ese segundo pase saca a la luz errores que la primera generación pasó por alto.

Conviene situar la reflexión dentro del bucle agéntico razonar-actuar-observar. Mientras que ese bucle sirve para actuar sobre el mundo (llamar a herramientas, consultar datos), la reflexión es un bucle interno que actúa sobre el propio texto del agente: no busca información nueva fuera, sino que mejora lo que el agente ya ha producido. Por eso encaja al final de una tarea de generación (escribir código, redactar un informe, resolver un problema de razonamiento) más que en la exploración de un entorno.

¿Cómo funcionan la autocrítica y la revisión de la salida?

En su forma más simple, la reflexión son dos roles que se turnan sobre un mismo texto. El generador produce un borrador. El crítico (el mismo modelo con otra instrucción, o un segundo modelo) lo evalúa contra unos criterios y devuelve una lista de defectos concretos. Con esa crítica, el generador reescribe. El ciclo se repite hasta que el crítico no encuentra fallos o hasta un número máximo de rondas. Este es el esqueleto del patrón:

def agente_con_reflexion(tarea, max_rondas=2):
    borrador = generar(tarea)              # primera versión
    for _ in range(max_rondas):
        critica = evaluar(tarea, borrador)  # el modelo se autocritica
        if "APROBADO" in critica:
            break                           # criterio cumplido: paramos
        borrador = revisar(tarea, borrador, critica)
    return borrador

La clave está en el prompt del crítico. Una crítica vaga ("mejora esto") apenas ayuda; una crítica accionable exige criterios explícitos: "comprueba que el código maneja la lista vacía, que los nombres son descriptivos y que hay una prueba por cada rama". Cuanto más objetivo sea el criterio, más fiable es la reflexión, porque el modelo puede verificar de verdad si lo cumple. Cuando existe una señal externa (un test que pasa o falla, un validador de JSON, un compilador), conviene alimentarla al crítico: deja de opinar y empieza a comprobar.

¿Qué proponen Reflexion y Self-Refine?

Dos artículos de 2023 formalizaron la idea y le dieron nombre. Self-Refine (arXiv 2303.17651[2]) plantea el caso más puro: un único modelo genera, se da retroalimentación a sí mismo y se corrige en iteraciones sucesivas, sin datos de entrenamiento ni ajuste de pesos. En siete tareas distintas (desde optimizar código hasta reescribir texto) obtuvo una mejora absoluta media cercana al 20 % con GPT-3.5, ChatGPT y GPT-4, y los evaluadores humanos prefirieron sus salidas. Su conclusión es contundente: incluso un modelo tan capaz como GPT-4 puede mejorar en tiempo de inferencia solo con criticarse.

Reflexion (arXiv 2303.11366[1]) va un paso más allá con lo que llama refuerzo verbal. Tras fallar en un intento, el agente escribe en lenguaje natural una reflexión sobre qué salió mal y la almacena en una memoria episódica; en el siguiente intento parte de esa lección aprendida. Es aprendizaje por refuerzo, pero sin tocar los pesos: el "gradiente" es texto. Con esta técnica, un agente de código alcanzó un 91 % de aciertos (pass@1) en el benchmark HumanEval, por encima del 80 % de GPT-4 sin reflexión. La misma idea de guardar y reutilizar lecciones enlaza la reflexión con la memoria a largo plazo del agente.

Anthropic recoge el patrón en su guía Building effective agents (diciembre de 2024) bajo el nombre de flujo evaluador-optimizador, y lo describe como "particularmente eficaz cuando tenemos criterios de evaluación claros y cuando el refinamiento iterativo aporta un valor medible".

¿Cuándo mejora los resultados la reflexión y cuándo no?

La reflexión no es gratis ni universal. Ayuda cuando se cumplen dos condiciones que Anthropic subraya: que exista un criterio de evaluación claro y que iterar aporte una mejora medible. Encaja de lleno en la generación de código (hay tests que pasan o fallan), en la escritura con una rúbrica, en problemas de razonamiento con pasos verificables y en traducciones donde un crítico detecta matices perdidos.

Rinde mucho menos, o incluso empeora, en tres situaciones. Primera: cuando no hay un criterio objetivo, el crítico inventa problemas o aprueba cualquier cosa. Segunda: cuando el modelo no sabe reconocer su propio error (si no domina el tema, criticarse no añade conocimiento que no tiene). Tercera: la sobrerreflexión, dar demasiadas vueltas hasta estropear una buena respuesta o entrar en bucle. Por eso el patrón fija un tope de rondas: en la práctica, una o dos suelen capturar casi toda la ganancia, y añadir más rondas rinde cada vez menos. Si dispones de una señal externa (un test, un validador), úsala como criterio de parada en lugar de la opinión del propio modelo, y mide el resultado con una herramienta como DeepEval antes de dar por hecho que la reflexión mejora nada.

¿Cuánto cuesta en tokens y latencia?

Este es el gran contrapeso. Una respuesta directa es una llamada al modelo; una respuesta con una ronda de reflexión son tres (generar, criticar, revisar), y con dos rondas, cinco. Además, cada llamada de crítica y revisión vuelve a enviar el borrador y el contexto, así que el consumo de tokens crece más rápido que el número de llamadas. En conjunto, es fácil multiplicar por tres o más el coste y la latencia frente a responder a la primera.

La decisión, por tanto, es económica además de técnica. Merece la pena cuando el valor de acertar es alto (código que va a producción, un informe que se publica) y hay margen de tiempo. No merece la pena en respuestas interactivas donde el usuario espera y donde un fallo se corrige a mano. Dos ajustes reducen la factura: limita las rondas a una o dos, y usa un modelo más pequeño y barato para el paso de crítica cuando la evaluación sea sencilla, reservando el modelo grande para generar y revisar.

Preguntas frecuentes

¿En qué se diferencia la reflexión del patrón ReAct?

En el objetivo del bucle. ReAct alterna razonamiento y acción para interactuar con el mundo: llama a herramientas, observa el resultado y decide el siguiente paso. La reflexión es un bucle interno que mejora la propia salida del agente sin buscar información nueva fuera. Son complementarios: un agente ReAct puede añadir un paso de reflexión al final para revisar su respuesta antes de entregarla.

¿Necesito dos modelos distintos para reflexionar?

No. En la versión más habitual, el mismo modelo hace de generador y de crítico, solo cambia la instrucción. Usar un segundo modelo (o el mismo con una configuración distinta) puede ayudar cuando quieres una mirada más independiente o abaratar la crítica con un modelo menor, pero no es imprescindible para empezar.

¿La reflexión elimina las alucinaciones?

No las elimina, las reduce cuando hay forma de comprobar la salida. Si el crítico dispone de una señal objetiva (un test, un validador, una fuente que contrastar) puede detectar y corregir errores factuales. Si solo se apoya en la opinión del propio modelo sobre un tema que no domina, puede incluso reforzar un error. La reflexión fiable necesita un criterio verificable.

Conclusión

El patrón de reflexión convierte un modelo que responde a la primera en un agente que revisa su trabajo: genera, se critica contra un criterio y reescribe, en una o dos rondas. Reflexion y Self-Refine demostraron que la técnica mejora resultados de forma medible (hasta un 91 % en HumanEval, ~20 % de media en Self-Refine) sin reentrenar el modelo, y Anthropic la recomienda cuando los criterios de evaluación son claros. El precio es multiplicar las llamadas y la latencia, así que resérvala para tareas donde acertar importe y puedas medir la mejora. El siguiente paso es enchufar una señal externa (un test o un validador) como criterio de parada y comprobar, con una evaluación real, que la reflexión aporta lo que promete.

Fuentes: [1] Reflexion, agentes de lenguaje con refuerzo verbal (arXiv)[1], [2] Self-Refine, refinamiento iterativo con autorretroalimentación (arXiv)[2], [3] Anthropic, cómo construir agentes eficaces[3], [4] LangChain, agentes de reflexión[4].

Visitas: 0

Fuentes

  1. arXiv 2303.11366
  2. arXiv 2303.17651
  3. Anthropic, cómo construir agentes eficaces
  4. LangChain, agentes de reflexión

Ruta: Fundamentos de los agentes de IA