La mayoría de agentes de IA fallan por una razón muy simple: hacen un intento, pero no convierten ese error en aprendizaje útil para el siguiente intento. Ahí es donde entra Reflexion, un enfoque presentado por Noah Shinn y colaboradores en 2023 que propone algo muy potente: en vez de actualizar los pesos del modelo, el agente aprende mediante feedback en lenguaje natural, guarda esas reflexiones en memoria episódica y las usa como contexto en la siguiente prueba. (arXiv)

Eso convierte a Reflexion en una pieza muy natural dentro de Agentic AI, porque un agente no es solo un generador de texto: es un sistema que observa, decide, actúa, evalúa resultados y vuelve a intentar. La propia documentación de LangChain diferencia los workflows, que siguen rutas fijas, de los agentes, que deciden dinámicamente su proceso y el uso de herramientas. Reflexion encaja precisamente en ese segundo mundo, donde hay ensayo, corrección y memoria. (Documentación LangChain)

Qué es exactamente Reflexion

Reflexion es un marco para reforzar agentes basados en lenguaje usando retroalimentación lingüística. Su idea central es sencilla: el agente intenta resolver una tarea, recibe una evaluación, genera una reflexión sobre lo que salió mal y conserva esa reflexión para rendir mejor en el siguiente intento. En el paper original, los autores lo describen como una forma de reforzar al agente sin fine-tuning, apoyándose en memoria y feedback textual. (arXiv)

Una forma muy útil de entenderlo es esta:

No es “pensar más” una sola vez.Es intentar, evaluar, reflexionar, recordar y reintentar.

Esa diferencia importa. En documentación reciente sobre patrones de agentes, se distingue entre una reflexión simple, que revisa una salida una vez, y Reflexion, que acumula memoria de fallos entre varios intentos. Esa persistencia es lo que le da valor real cuando un problema requiere prueba y error. (agent-patterns.readthedocs.io)

Cómo funciona por dentro

En la formulación más conocida, Reflexion se apoya en tres papeles:

1. Actor: genera texto o acciones a partir del estado actual.
2. Evaluator: puntúa o evalúa la trayectoria producida.
3. Self-Reflection: redacta el aprendizaje verbal que servirá para el siguiente intento. (promptingguide.ai)

El ciclo mental sería algo así:

• el agente actúa,
• el entorno devuelve observaciones o resultados,
• un evaluador decide si el intento fue bueno o malo,
• el módulo de reflexión extrae una lección útil,
• esa lección se guarda en memoria,
• el siguiente intento parte ya de esa experiencia acumulada. (promptingguide.ai)

Lo interesante es que el feedback no tiene por qué ser siempre del mismo tipo. El paper señala que Reflexion puede incorporar señales escalares o texto libre, y que esas señales pueden venir de fuentes externas o internas. Eso lo vuelve muy flexible para tareas de razonamiento, programación o toma de decisiones. (arXiv)

Por qué Reflexion importa tanto en Agentic AI

En Agentic AI no basta con contestar bien una sola vez. Muchas tareas reales exigen explorar, fallar, corregir y volver a intentar: depurar código, navegar herramientas, planificar pasos o resolver problemas donde el primer intento rara vez es perfecto. Reflexion es atractivo porque convierte esos fallos en una memoria operativa que guía nuevas decisiones. (promptingguide.ai)

Además, el paper original reportó mejoras fuertes frente a agentes base en varias tareas y, en su configuración experimental, informó un 91% pass@1 en HumanEval, frente al 80% atribuido a GPT-4 en ese trabajo. Conviene leer ese dato como un resultado del estudio original, no como una garantía universal para cualquier modelo actual o cualquier benchmark moderno. (arXiv)

La contrapartida también es clara: reflexionar cuesta tiempo y cómputo. LangChain lo resume muy bien al explicar que estos enfoques suelen intercambiar más latencia por mejor calidad. Por eso Reflexion brilla cuando la calidad importa más que la inmediatez. (LangChain Blog)

Cuándo usarlo y cuándo no

Reflexion encaja especialmente bien cuando existe un criterio de evaluación claro: tests que pasan o fallan, reglas verificables, objetivos observables o feedback relativamente estable. También funciona mejor en problemas donde una mala respuesta inicial puede corregirse iterativamente. (agent-patterns.readthedocs.io)

En cambio, no suele ser la mejor elección para tareas de una sola pasada, experiencias muy sensibles a coste o casos donde el éxito es ambiguo y nadie puede decir con claridad si el agente ha mejorado. También es poco recomendable cuando la latencia debe ser mínima. (agent-patterns.readthedocs.io)

Un ejemplo mental muy simple

Imagina un agente que tiene que redactar una descripción de producto.

En un enfoque tradicional:

• genera una versión,
• la entrega,
• termina.

En Reflexion:

• genera una versión,
• un evaluador revisa si cumple longitud, tono y palabras clave,
• el sistema redacta una reflexión como “faltan beneficios concretos y una llamada a la acción”,
• guarda esa nota,
• vuelve a generar una nueva versión usando esa memoria.

Eso ya no es un chatbot lineal. Es un agente que aprende de su propio historial inmediato.

Ejemplo 1 en Python: entender Reflexion sin usar ninguna API

Este ejemplo no llama a ningún modelo externo. La idea es aprender la lógica del patrón.

# Mini ejemplo didáctico de Reflexion
# Tarea: generar una frase útil sobre Python que cumpla ciertas reglas

objetivo = {
    "min_palabras": 12,
    "palabras_clave": ["Python", "automatizar", "datos"]
}

memoria = []

def actor(memoria):
    """
    Genera una respuesta.
    Aquí simulamos al 'actor' usando la memoria acumulada.
    """
    texto = "Python es útil para programar."

    if memoria:
        ultima_reflexion = memoria[-1].lower()

        if "más larga" in ultima_reflexion:
            texto += " También ayuda a resolver tareas del día a día."
        if "automatizar" in ultima_reflexion:
            texto += " Sirve para automatizar procesos repetitivos."
        if "datos" in ultima_reflexion:
            texto += " Además, permite analizar datos con facilidad."

    return texto

def evaluar(texto, objetivo):
    """
    Comprueba si la respuesta cumple las reglas.
    """
    errores = []

    if len(texto.split()) < objetivo["min_palabras"]:
        errores.append("Haz la respuesta más larga.")

    for palabra in objetivo["palabras_clave"]:
        if palabra.lower() not in texto.lower():
            errores.append(f"Incluye la idea: {palabra}.")

    aprobado = len(errores) == 0
    return aprobado, errores

def reflexionar(errores):
    """
    Convierte errores en aprendizaje textual.
    """
    if not errores:
        return "La estrategia actual funciona."
    return " ".join(errores)

max_intentos = 3

for intento in range(1, max_intentos + 1):
    respuesta = actor(memoria)
    ok, errores = evaluar(respuesta, objetivo)

    print(f"\nIntento {intento}")
    print("Respuesta:", respuesta)

    if ok:
        print("Estado: aprobado")
        break

    aprendizaje = reflexionar(errores)
    memoria.append(aprendizaje)

    print("Estado: falló")
    print("Reflexión guardada:", aprendizaje)

print("\nMemoria final:", memoria)

Qué enseña este ejemplo

Aquí aparecen ya las tres piezas esenciales:

• Actor: genera una salida.
• Evaluator: comprueba si cumple el objetivo.
• Reflection: transforma los fallos en instrucciones para el próximo intento.

No hay magia. El patrón de Reflexion, en el fondo, consiste en convertir el error en texto reutilizable.

Ejemplo 2 en Python: un agente que corrige código con tests

Este segundo ejemplo se parece más a un caso real de Agentic AI, porque el evaluador ya no usa reglas vagas, sino tests deterministas.

# Mini Reflexion para una tarea de programación
# Objetivo: crear una función que devuelva los cuadrados de los números pares

memoria = []

def actor_codigo(memoria):
    """
    Simula distintas versiones del código según la memoria acumulada.
    """
    if not memoria:
        # Primer intento: incorrecto
        return """
def cuadrados_pares(nums):
    return [n * n for n in nums]
"""
    ultima_reflexion = memoria[-1].lower()

    if "filtra" in ultima_reflexion or "pares" in ultima_reflexion:
        # Segundo intento: corregido
        return """
def cuadrados_pares(nums):
    return [n * n for n in nums if n % 2 == 0]
"""

    return """
def cuadrados_pares(nums):
    return nums
"""

def evaluar_codigo(codigo):
    """
    Ejecuta el código y comprueba si pasa los tests.
    """
    tests = [
        ([1, 2, 3, 4], [4, 16]),
        ([2, 6, 7], [4, 36]),
        ([1, 3, 5], [])
    ]

    entorno = {}

    try:
        exec(codigo, entorno)
        funcion = entorno["cuadrados_pares"]

        for entrada, esperado in tests:
            obtenido = funcion(entrada)
            if obtenido != esperado:
                return False, f"Fallo con {entrada}. Esperado: {esperado}, obtenido: {obtenido}"

        return True, "Todos los tests pasaron"

    except Exception as e:
        return False, f"Error al ejecutar el código: {e}"

def reflexionar_codigo(resultado):
    """
    Convierte el fallo en una lección útil.
    """
    if "Esperado" in resultado and "obtenido" in resultado:
        return "Filtra solo los números pares antes de elevar al cuadrado."
    if "Error al ejecutar" in resultado:
        return "Revisa la sintaxis y el nombre de la función."
    return "La solución parece correcta."

for intento in range(1, 4):
    codigo = actor_codigo(memoria)
    ok, mensaje = evaluar_codigo(codigo)

    print(f"\nIntento {intento}")
    print(codigo)
    print("Evaluación:", mensaje)

    if ok:
        print("Código aprobado")
        break

    aprendizaje = reflexionar_codigo(mensaje)
    memoria.append(aprendizaje)
    print("Reflexión guardada:", aprendizaje)

print("\nMemoria final:", memoria)

Qué enseña este segundo ejemplo

Este patrón ya se acerca mucho más a un agente útil de verdad:

• el actor propone una solución,
• el evaluador ejecuta pruebas,
• la reflexión resume la lección,
• la memoria orienta el siguiente intento.

Cuando esta estructura se conecta a un LLM real, el comportamiento se vuelve mucho más flexible. Pero la lógica sigue siendo exactamente la misma.

La lección más importante

Reflexion no consiste en “hacer prompts más largos”. Consiste en construir un bucle donde el agente pueda:

• fallar con criterio,
• recibir una evaluación,
• extraer una lección concreta,
• y usar esa lección en el siguiente intento.

Eso es lo que transforma una salida estática en un comportamiento agentic mucho más interesante.

Conclusión

Reflexion sigue siendo una de las ideas más elegantes dentro de Agentic AI porque resuelve un problema central: cómo hacer que un agente mejore entre intentos sin tener que reentrenar el modelo cada vez. Su combinación de memoria episódica, evaluación y aprendizaje verbal lo convierte en un patrón especialmente valioso para programación, razonamiento y tareas con criterios claros de éxito. (arXiv)

Dicho de forma directa: si un agente va a trabajar en entornos reales, necesita algo más que generar texto. Necesita recordar por qué falló y ajustar su siguiente decisión. Ahí es donde Reflexion deja de ser una técnica interesante y pasa a convertirse en una arquitectura muy seria para construir agentes que evolucionan intento a intento. (LangChain Blog)

Toni Domenech