Cuando un agente funciona bien, parece magia.
Le das una tarea, no explicas nada, no controlas cada paso, y el sistema encuentra datos, elige herramientas y vuelve con un resultado.
Y en algún momento empieza a parecer que entiende lo que hace.
Y luego, de repente:
- Usa la herramienta equivocada
- Olvida la mitad de la tarea
- Hace una solicitud extra a la API
- O devuelve con seguridad un completo sinsentido
Y lo peor: lo hace de forma muy convincente.
Sin errores de texto.
Sin dudar.
Como si todo estuviera correcto.
En ese momento aparece una pregunta lógica:
¿Cómo pudo un sistema que acababa de actuar de forma inteligente cometer ese error?
Porque dentro no hay razonamiento
Para entender por qué un agente a veces se equivoca, hay que mirar cómo toma decisiones en realidad.
Porque dentro de él no hay "razonamiento".
Un agente de IA no piensa. No verifica hechos. No entiende qué es correcto y qué no.
Funciona a través de un modelo de lenguaje.
Y un modelo de lenguaje no sabe las respuestas.
No busca la verdad. No abre una base de conocimiento. No verifica la realidad.
Elige la siguiente acción o respuesta que parece más probable en ese contexto.
Cada vez que el agente:
- Decide el siguiente paso
- Elige una herramienta
- Escribe una solicitud
- O evalúa un resultado
— eso es solo un intento de adivinar qué parece más correcto en este contexto.
Y a veces esa suposición es incorrecta.
| Humano | LLM | |
|---|---|---|
| Verifica hechos | ✅ | ❌ |
| Conoce la respuesta | A veces | ❌ |
| Predice la respuesta | ❌ | ✅ |
Cómo toma decisiones un agente en realidad
El agente no sabe qué acción es correcta.
Pero está entrenado con una enorme cantidad de ejemplos de cómo se ve una acción correcta en situaciones parecidas.
Durante el entrenamiento, el modelo vio:
- Cómo se ven las solicitudes a API
- Cómo se analizan datos
- Cómo se construyen informes
- Cómo se usan herramientas
Y ahora, cuando el agente trabaja, mira:
- La meta
- Los pasos previos
- Los resultados obtenidos
Y se hace esta pregunta:
"¿Qué acción se parece más a una que ayudó antes en una situación parecida?"
Por ejemplo, cuando todo va bien:
El agente recibe la tarea: "Recopila datos del cliente."
En el contexto hay una herramienta: get_user_data(user_id)
El modelo "sabe" que en tareas parecidas:
- Primero se obtienen datos
- Luego se analizan
Y por eso elige: llamar get_user_data
No porque esté seguro.
Sino porque parece el siguiente paso lógico.
Pero aquí es cuando todo sale mal:
El agente recibe la tarea: "Escribe una breve reseña de la empresa para un cliente nuevo."
En el contexto hay notas antiguas de una reunión con otro cliente, con formato similar.
El modelo ve un patrón parecido y piensa:
"En una situación parecida normalmente se usan datos que ya están disponibles."
Y por eso genera una reseña, pero de otra empresa.
Con confianza. Sin advertencias. Con texto bien formateado.
Simplemente no sobre el cliente correcto.
Después de cada paso vuelve a predecir:
"¿Qué se suele hacer después de esto?"
Y así, paso a paso.
Por eso el agente muchas veces toma acciones correctas.
Pero a veces, no.
Porque no verifica si es verdad.
Solo elige lo que parece más adecuado en este contexto.
En código se ve así
Abajo está el mismo principio en un formato simple:
el modelo no "conoce la verdad", elige el paso que parece más probable en el contexto actual.
Primero tenemos acciones (herramientas) que se pueden llamar:
def fetch_company_profile(company_id: str):
return {"company_id": company_id, "summary": "Official profile"}
def summarize_notes(notes: str):
return {"summary": f"Summary from notes: {notes}"}
TOOLS = {
"fetch_company_profile": fetch_company_profile,
"summarize_notes": summarize_notes,
}
Ahora tenemos el contexto de la tarea:
state = {
"task_company_id": "acme",
"old_notes": "Meeting notes about beta-corp", # notas antiguas sobre otra empresa
}
El modelo hace una suposición sobre el siguiente paso:
def choose_action(state: dict):
# Si ya hay notas en el contexto, el modelo puede decidir
# que eso es "suficiente" para una reseña rápida.
if state.get("old_notes"):
return {
"tool": "summarize_notes",
"parameters": {"notes": state["old_notes"]},
}
return {
"tool": "fetch_company_profile",
"parameters": {"company_id": state["task_company_id"]},
}
El sistema ejecuta lo que el modelo propuso:
model_output = choose_action(state)
tool_name = model_output["tool"]
params = model_output["parameters"]
result = TOOLS[tool_name](**params)
En este caso, el resultado será "convincente", pero de la empresa incorrecta:
# {'summary': 'Summary from notes: Meeting notes about beta-corp'}
Para reducir el riesgo, agregamos una verificación simple de fuente antes de la respuesta final:
def validate_summary_source(state: dict, result: dict):
if "beta-corp" in result.get("summary", "") and state["task_company_id"] == "acme":
return {"error": "Incompatibilidad de contexto: los datos son de otra empresa"}
return {"ok": True}
Esto no elimina por completo los límites de LLM, pero reduce este tipo de errores en producción.
Ejemplo completo de implementación con LLM conectada
Analogía de la vida real
Imagina a un cocinero principiante que vio miles de videos de recetas.
Vio:
- Cómo freír carne
- Cómo cocinar sopa
- Cómo preparar salsas
- Cómo servir platos
Pero no recuerda ni una receta palabra por palabra.
Y no sabe con certeza cómo preparar correctamente cada plato.
Ahora le pides: "Prepara algo parecido a una carbonara."
No abre un libro. No verifica instrucciones.
Piensa:
"¿Qué se suele hacer en un plato parecido?"
Y:
- Añade crema
- Fríe tocino
- Lo mezcla con pasta
A veces sale muy bien.
A veces, raro.
Porque no sabe qué es lo correcto.
Solo hace lo que más se parece a una receta correcta que vio antes.
El agente funciona igual.
No sabe qué acción es correcta. Y no recuerda soluciones listas.
Elige la que más se parece a la correcta en una situación similar.
En resumen
Un modelo de lenguaje no es razonamiento:
- No conoce respuestas correctas
- No verifica hechos
- Solo genera la continuación más probable
Por eso un agente puede parecer muy inteligente y al mismo tiempo equivocarse con seguridad, sin ninguna advertencia.
No es un bug de un sistema específico. Es la naturaleza fundamental de cómo funcionan los modelos de lenguaje.
¿Qué hacer con esto? Entender esta limitación ya es el primer paso. Luego hay formas concretas de volver al agente más confiable: darle contexto claro, limitar herramientas, añadir validación de resultados. Y una de las más importantes es darle memoria.
FAQ
Q: ¿El agente sabe que su respuesta es correcta?
A: No. Elige la opción que parece más probable en ese contexto.
Q: ¿Puede el modelo verificarse a sí mismo?
A: Puede intentar evaluar su respuesta, pero también será una suposición.
Q: ¿Por qué el agente suena seguro incluso cuando se equivoca?
A: Porque el modelo está entrenado para generar texto plausible, no para dudar.
Qué sigue
Ahora sabes por qué un agente puede equivocarse y que eso no viene de descuido, sino de la naturaleza de la tecnología.
Hay varias formas de hacer al agente más confiable: instrucciones claras, conjunto limitado de herramientas, validación de resultados. Pero una de las más efectivas y más interesantes es la memoria.
Si un agente puede recordar:
- Qué ya se hizo
- Qué herramientas funcionaron
- Qué datos obtuvo antes
Empieza a depender menos de suposiciones y más de experiencia concreta dentro de esta tarea.
De eso trata exactamente el siguiente artículo.