Memoria del agente: qué recuerda y para qué

Cuando un agente ejecuta una tarea, no solo reacciona a la instrucción actual.

Tiene en cuenta lo que ya pasó antes: lo que pediste, lo que ya hizo y qué resultado obtuvo.

Sin esto, cada acción nueva sería como un primer intento.

Volvería a llamar la misma API o repetiría un paso que ya no funcionó

— a veces, infinitamente.

Precisamente la memoria permite que el agente avance en lugar de girar en círculo.

Qué es la memoria del agente y de qué se compone

La memoria del agente no es un único lugar donde se guarda toda la información.

Es un conjunto de mecanismos que le permiten:

• guardar el contexto de la tarea actual
• y usar experiencia de tareas anteriores

Sin ellos, el agente no sabe: qué ya se hizo
qué funcionó
y qué debe hacer después

Memoria de corto plazo vs largo plazo

No toda la memoria del agente es igual.

Hay memoria durante la tarea.
Y hay memoria entre tareas.

La de corto plazo existe solo durante la tarea.

Es el contexto de la conversación actual:

• tus instrucciones
• respuestas del agente
• resultados de pasos anteriores

Cuando la tarea termina, este contexto desaparece.

La próxima vez, el agente arranca "desde cero".

La de largo plazo se guarda entre tareas.

Le permite:

• recordar configuraciones
• tener en cuenta experiencia previa
• usar datos de tareas pasadas

Sin ella, cada tarea nueva es como la primera.

Ejemplo simple:

Le dices al agente: "Haz el informe como la vez pasada."

Con memoria de corto plazo, no sabe qué fue "la vez pasada".
Con memoria de largo plazo, conoce formato, fuentes y estructura, y puede repetirlo.

Qué recuerda el agente dentro de una tarea

Cuando el agente trabaja en una tarea, "ve" solo la conversación actual.

Todo lo que escribes.
Todo lo que responde el agente.
Todos los resultados que recibe de herramientas.

Esa es su memoria de corto plazo: el contexto.

La usa para:

• Entender qué está pasando ahora
• Decidir qué paso dar después
• Y no repetir lo que ya se hizo

Pero este contexto no es infinito.

Si la conversación se vuelve demasiado larga, parte de la información antigua simplemente se cae.

El agente deja de verla.

Y puede:

• Olvidar la instrucción inicial
• Perder un detalle importante
• O hacer una acción que ya había hecho antes

Qué puede recordar el agente entre tareas

Cuando la tarea termina, el contexto de la conversación desaparece.

Pero eso no significa que el agente deba olvidarlo todo para siempre.

Puede guardar parte de la información en una memoria externa.

Puede ser:

• Una base de datos
• Un archivo
• U otro almacenamiento

Donde el agente escribe:

• Configuraciones
• Decisiones anteriores
• O hechos importantes

Y en la siguiente tarea puede leer esos datos de vuelta.

Así recuerda:

• Cómo trabajas
• Qué formatos usas
• O qué hizo antes

Aunque la conversación anterior haya terminado hace tiempo.

Límite de memoria: ventana de contexto

La memoria de corto plazo del agente tiene límites.

No puede recordar toda la conversación completa.

Hay un volumen máximo de contexto que el modelo puede "ver" al mismo tiempo.

Esto se llama ventana de contexto.

Cuando la conversación se vuelve demasiado larga, parte de la información antigua simplemente ya no entra.

Se sale del contexto.

El agente ya no la considera.

Por eso puede:

• Olvidar la instrucción inicial
• Perder un detalle importante
• O repetir una acción que ya había ejecutado antes

En código se ve así

Abajo está el mismo principio en formato simple:
hay memoria de corto plazo (contexto de tarea) y de largo plazo (almacenamiento externo entre tareas).

1) Memoria de corto plazo: qué "ve" el agente ahora

Son los mensajes actuales y resultados de los últimos pasos:

short_memory = [
    {"role": "user", "content": "Prepara un informe semanal de ventas"},
    {"role": "assistant", "content": "Ok, empiezo a recopilar datos"},
    {"role": "tool", "content": "sales_total=12400"},
]

2) Límite de contexto: lo viejo puede caerse

Si el contexto es limitado, el sistema deja solo los últimos elementos:

MAX_ITEMS = 3
short_memory = short_memory[-MAX_ITEMS:]

Por eso el agente puede dejar de ver instrucciones tempranas.

3) Memoria de largo plazo: qué guardamos entre tareas

Por separado mantenemos almacenamiento con hechos útiles:

long_memory_store = {
    "user:anna": {
        "report_format": "short-bullets",
        "currency": "USD",
    }
}

4) En la nueva tarea leemos esos datos de vuelta

Antes de responder, el agente recupera configuraciones guardadas:

user_prefs = long_memory_store.get("user:anna", {})

task_context = {
    "request": "Haz el informe como la vez pasada",
    "prefs": user_prefs,
}

5) El agente construye la respuesta usando memoria

def build_report(context: dict):
    fmt = context["prefs"].get("report_format", "default")
    currency = context["prefs"].get("currency", "USD")
    return f"Report format={fmt}, currency={currency}"


result = build_report(task_context)
# "Report format=short-bullets, currency=USD"

Sin memoria de largo plazo esto sería format=default.

Analogía de la vida real

Imagina que hablas por teléfono, pero oyes solo los últimos 30 segundos de la conversación.

Sabes lo que la otra persona acaba de decir.
Recuerdas la última respuesta.
Y puedes seguir la conversación.

Pero si dice:

"Como ya expliqué al principio..."

— ese principio no lo oíste.

Simplemente se cayó.

Y puedes:

• Volver a preguntar lo mismo
• Entender mal la tarea
• O responder fuera de tema

Si tienes notas de llamadas anteriores, puedes releerlas y recuperar el contexto.

Así es exactamente como el agente usa memoria de corto y largo plazo.

En resumen

FAQ

Q: ¿El agente recuerda tareas anteriores?
A: Solo si esa información está guardada en memoria de largo plazo fuera de la conversación actual.

Q: ¿Por qué el agente puede olvidar la instrucción inicial?
A: Por límites de la ventana de contexto: parte de la información antigua puede caerse de la memoria de corto plazo.

Q: ¿Para qué necesita memoria de largo plazo?
A: Para guardar datos importantes entre tareas y usarlos en el futuro.

Qué sigue

Ahora sabes qué recuerda el agente y cómo eso le ayuda a avanzar.

Pero la memoria es solo una parte del panorama.

Porque el agente no solo recuerda acciones.
Las ejecuta.

Y no todas las acciones son igual de seguras.

Una cosa es leer datos.
Otra es modificarlos.
O eliminarlos.
O gastar dinero en API.

Por eso el agente no solo necesita saber qué hacer.
Necesita saber qué está permitido hacer.