¿Qué es un Agente de Reflexión (Self-Reflection)?

Un agente de reflexión (self-reflection agent) es un sistema que evalúa críticamente su propio output antes de darlo por bueno. En lugar de generar una respuesta y enviarla directamente, el agente la revisa, identifica posibles errores, inconsistencias o mejoras, y la refina en uno o más ciclos de corrección. Esto convierte al LLM de un generador de una sola pasada en un sistema que se autoverifica — similar a cómo un humano relee un email antes de enviarlo.

Tip Pro: La reflexión es la técnica más simple para reducir alucinaciones sin cambiar de modelo ni hacer RAG. Un solo ciclo de autocrítica puede atrapar entre el 20-40% de los errores factuales.

¿Qué es?

El patrón de reflexión añade un bucle de verificación después de la generación inicial. El flujo típico es:

Generate: el LLM produce una respuesta inicial al prompt del usuario.
Reflect: el mismo LLM (u otro) evalúa la respuesta contra criterios definidos — exactitud, completitud, tono, seguridad.
Refine: si la evaluación encuentra problemas, el modelo genera una versión corregida.
Repeat: los pasos 2 y 3 se repiten hasta que la respuesta pasa la evaluación o se alcanza un límite de iteraciones.

Hay dos arquitecturas comunes:

Auto-reflexión (mismo modelo): el mismo LLM genera y luego se evalúa. Es más barato, pero el modelo puede tener los mismos sesgos en ambas fases.
Reflexión con evaluador separado: un modelo más pequeño y rápido valida al modelo principal, o viceversa (un modelo más grande evalúa a uno más pequeño).

Nota: La reflexión no es lo mismo que CoT. CoT ocurre antes de la respuesta (razonamiento paso a paso). La reflexión ocurre después de la respuesta (evaluación y corrección).

Modelo mental

Imagina a un escritor que termina un artículo y luego se pone el sombrero de editor. Como escritor, produce texto. Como editor, lo lee con ojo crítico, marca problemas y lo devuelve para corrección. El agente de reflexión alterna entre estos dos roles: primero escribe, luego se critica, luego reescribe.

Generación inicial → ¿Es correcto? → Sí → Respuesta final
                         ↓ No
                   Corrección → ¿Es correcto? → Sí → Respuesta final
                                     ↓ No
                               Corrección (máx N iteraciones)

Cada ciclo consume tokens. El costo de la reflexión es el costo de las iteraciones adicionales.

¿Cómo se usa?

Auto-reflexión con un solo modelo

El patrón más simple: después de generar, le pides al modelo que critique su propia respuesta.

def generar_con_reflexion(pregunta, max_iteraciones=3):
    messages = [{"role": "user", "content": pregunta}]
 
    for i in range(max_iteraciones):
        # Paso 1: generar respuesta
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )
        respuesta = response.choices[0].message.content
        messages.append({"role": "assistant", "content": respuesta})
 
        # Paso 2: pedir autoevaluación
        critica = client.chat.completions.create(
            model="gpt-4o",
            messages=messages + [{
                "role": "user",
                "content": """Evalúa críticamente tu respuesta anterior.
                ¿Tiene errores factuales? ¿Omite algo importante?
                ¿Es clara y completa? Si es correcta, responde solo 'ACEPTABLE'.
                Si necesita cambios, explica qué corregir."""
            }]
        )
        feedback = critica.choices[0].message.content
 
        if "ACEPTABLE" in feedback.upper():
            return respuesta
 
        # Paso 3: refinar con el feedback
        messages.append({"role": "user", "content": f"""
        Tu respuesta anterior tiene estos problemas:
        {feedback}
 
        Por favor, genera una versión corregida.
        """})
 
    # Último intento como fallback
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages + [{"role": "user",
                              "content": "Genera la mejor versión final."}]
    )
    return response.choices[0].message.content

Advertencia: El modelo tiende a ser indulgente consigo mismo en la autoevaluación. Para resultados más objetivos, usa un prompt de crítica severo o un modelo separado como evaluador.

Reflexión con evaluador separado

Usas un modelo más barato (ej: GPT-4o mini) para evaluar al modelo principal:

def generar_con_evaluador(pregunta):
    modelo_principal = "gpt-4o"
    modelo_evaluador = "gpt-4o-mini"
 
    # Generar respuesta inicial
    response = client.chat.completions.create(
        model=modelo_principal,
        messages=[{"role": "user", "content": pregunta}]
    )
    respuesta = response.choices[0].message.content
 
    # Evaluar con un modelo separado
    eval_response = client.chat.completions.create(
        model=modelo_evaluador,
        messages=[{
            "role": "system",
            "content": "Eres un evaluador severo. Revisa la respuesta del asistente."
        }, {
            "role": "user",
            "content": f"Pregunta: {pregunta}\nRespuesta: {respuesta}\n\n¿La respuesta es factualmente correcta y completa? Si no, explica qué falta."
        }]
    )
    feedback = eval_response.choices[0].message.content
 
    if "correcta" in feedback.lower() and "completa" in feedback.lower():
        return respuesta
 
    # Refinar con el feedback
    refinement = client.chat.completions.create(
        model=modelo_principal,
        messages=[{"role": "user", "content": pregunta},
                  {"role": "assistant", "content": respuesta},
                  {"role": "user", "content": f"Corrige: {feedback}"}]
    )
    return refinement.choices[0].message.content

Reflexión estructurada con criterios explícitos

En lugar de una crítica libre, defines criterios específicos que el evaluador debe verificar:

criterios = [
    "¿La respuesta responde directamente a la pregunta del usuario?",
    "¿Cada afirmación factual es verificable?",
    "¿La respuesta cita fuentes cuando corresponde?",
    "¿El tono es apropiado para el contexto?",
    "¿La respuesta es autónoma (no necesita más contexto)?"
]
 
def evaluar_con_criterios(pregunta, respuesta):
    prompt = f"""Evalúa la siguiente respuesta según estos criterios.
Responde con un JSON donde cada criterio tiene "pass" o "fail".
 
Pregunta: {pregunta}
Respuesta: {respuesta}
 
Criterios:
{chr(10).join(f'- {c}' for c in criterios)}
"""
    result = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )
    return json.loads(result.choices[0].message.content)

¿Cuándo usarlo / cuándo no?

✅ Úsalo cuando	❌ NO lo uses cuando
La precisión es crítica (medicina, finanzas, legal)	La latencia importa más que la precisión
El modelo comete errores predecibles en ciertos temas	El costo por llamada debe ser mínimo
No tienes acceso a un modelo más grande o RAG	Un solo ciclo de generación ya da resultados aceptables
El usuario valora respuestas pulidas y revisadas	La respuesta es efímera (ej: sugerencias en tiempo real)
Quieres reducir alucinaciones sin infraestructura extra	No tienes criterios claros para definir qué es "correcto"

Tip Pro: Pon un límite de 2-3 iteraciones máximo. Más allá, el modelo tiende a sobrecorregir, introduciendo nuevos errores o alargando la respuesta innecesariamente. Mide cuántas iteraciones realmente mejoran la calidad antes de fijar el límite.

Historia y evolución

Ver historia

El patrón de auto-reflexión fue formalizado en el paper "Reflexion: Language Agents with Verbal Reinforcement Learning" (Shinn et al., 2023), donde los autores propusieron que un agente mantuviera una "memoria episódica" de sus errores pasados y usara feedback textual para corregirse.

Simultáneamente, trabajos como "Self-Critiquing Models" y "Constitutional AI" (Anthropic, 2023) exploraron cómo los modelos pueden evaluar su propio output contra principios definidos. El enfoque de Constitutional AI entrena al modelo para preferir respuestas que cumplan ciertas reglas, internalizando la reflexión en los pesos.

Hoy la reflexión es un componente estándar en sistemas multi-agente y en pipelines de generación donde la calidad es crítica, complementando técnicas como RAG y guardrails.