Por que tu agente AI recuerda demasiado (y como solucionarlo)

Probamos 4 sistemas de memoria diferentes para nuestros agentes AI. Todos almacenaban demasiada basura.

Las bases de datos vectoriales guardaban cada mensaje - incluyendo “si,” “ok,” y “puedes repetir eso?” Los logs de conversacion crecian a megabytes de ruido. El retrieval RAG devolvia 10 fragmentos irrelevantes por cada uno util. Y el costo en tokens de hacer embedding de todo era absurdo.

TL;DR

Almacena menos, recuerda mejor - la mayoria de los sistemas de memoria almacenan todo y recuperan mal. La memoria selectiva e intencional supera a la memoria total siempre.
Ensena al agente sobre sus propias limitaciones - el system prompt debe decir explicitamente “tu contexto contiene 10 mensajes.” Sin esto, el agente asume que recuerda todo.
“Guardar inmediatamente” es la regla critica - si el agente no guarda la informacion en el momento en que la aprende, se pierde cuando el contexto cambia. No hay segunda oportunidad.
La memoria basada en archivos es simple y depurable - puedes leer, editar y versionar los archivos de memoria del agente con git. Intenta hacer eso con una base de datos vectorial.
Combina estrategias de corto y largo plazo - la summarization maneja el contexto reciente, la memoria basada en archivos maneja el conocimiento persistente, la busqueda de historial maneja consultas poco frecuentes.

El problema fundamental

El problema fundamental: la mayoria de los sistemas de memoria AI estan disenados para recordar todo. Pero la mejor memoria humana funciona olvidando casi todo y conservando solo lo que importa.

Despues de anos de trabajo productivo con agentes en Vstorm, convergimos en un enfoque diferente. En lugar de almacenar cada mensaje en una base de datos vectorial, le damos al agente un sistema de archivos estructurado para memoria persistente - y le ensenamos a decidir que vale la pena guardar.

El problema: las ventanas de contexto son finitas

Aqui hay un hecho que la mayoria de las arquitecturas de agentes ignoran: tu ventana de contexto solo contiene los ultimos ~10-20 mensajes. Todo lo anterior desaparecio - a menos que lo guardes explicitamente en algun lugar.

Una configuracion tipica de produccion:

Ventana de contexto: 128k tokens (GPT-4o) o 200k tokens (Claude)
Mensaje promedio: ~500 tokens (con llamadas a herramientas)
Capacidad efectiva: ~50-100 mensajes antes de que entre la gestion de contexto
Con summarization: ~20 mensajes recientes + un resumen comprimido

Despues de 50 intercambios, tu agente no recuerda el nombre del usuario del mensaje #3. No porque sea tonto - porque la informacion literalmente ya no esta en el contexto.

La solucion: Memoria estructurada basada en archivos

En lugar de volcar todo en una base de datos vectorial, le damos al agente un sistema de archivos organizado por proposito:

/memory/
├── AGENTS.md              # Core instructions, learned behaviors
├── knowledge/
│   ├── user.md            # User's name, preferences, timezone
│   ├── projects/
│   │   └── api-project.md # Project-specific context
│   └── tech-stack.md      # Preferred technologies
├── skills/
│   ├── task-planning.md   # How to plan complex tasks
│   └── code-review.md     # How to review code
└── conversations/
    └── summaries/         # Summaries of important past conversations

El agente lee estos archivos al inicio de cada conversacion y los actualiza cuando aprende algo nuevo. No es almacenamiento automatico - es gestion intencional de la memoria.

La regla de “Guardar inmediatamente”

La instruccion critica en el system prompt del agente:

system_prompt = f"""
## CRITICAL: Context Window Limitations

**Your context window only holds the last 10 messages.** This means:
- Information shared earlier in the conversation WILL BE LOST
- User preferences, names, project details - all forgotten after ~10 exchanges
- You MUST proactively save important information to your persistent memory

**When to save to memory (DO THIS IMMEDIATELY):**
- User tells you their name → Save to knowledge/user.md
- User shares preferences → Save to AGENTS.md under "User Preferences"
- User describes a project → Save to knowledge/projects/
- User corrects you → Update relevant memory file
- Important facts → Save to knowledge/

**Example:** If user says "My name is Kacper", IMMEDIATELY:
1. Acknowledge: "Nice to meet you, Kacper!"
2. Save to memory: edit_file("knowledge/user.md", ...)
"""

La idea clave: no guardes todo. Guarda solo lo que necesitarias si perdieras toda la conversacion. El agente toma esta decision - no una heuristica, no un embedding, no un umbral de similitud vectorial. El LLM mismo decide que vale la pena recordar.

Rutina de inicio: Leer antes de responder

Cada conversacion comienza con una carga de memoria:

# Agent's startup routine (from system prompt):
# 1. Read AGENTS.md to recall your instructions
# 2. Read knowledge/user.md to remember the user
# 3. Check if skills/ has relevant skills for this topic

Esto es barato - leer 3-4 archivos markdown pequenos cuesta unos pocos cientos de tokens. Pero significa que el agente sabe con quien esta hablando, en que proyectos trabajan y como prefieren comunicarse.

AGENTS.md: La memoria central del agente

El archivo AGENTS.md sirve como la identidad y los comportamientos aprendidos del agente:

# Winston - Core Instructions

## Identity
You are Winston, an autonomous AI assistant.

## Critical Behaviors

### Memory Management
- Your context window is LIMITED to ~10 messages
- Important information WILL BE LOST if not saved
- When user shares personal info → SAVE IMMEDIATELY

### Proactive Learning
When you learn something new about the user:
1. Acknowledge what you learned
2. Save to appropriate memory file
3. Confirm: "I've noted that for future reference."

## User Preferences
- Language: User may speak Polish or English - match their language
- Code style: Prefers explicit over clever

Este archivo crece organicamente. Cuando el agente aprende que el usuario prefiere TypeScript sobre JavaScript, actualiza la seccion User Preferences. Cuando comete un error y es corregido, agrega una entrada en “Learned Behaviors.”

Skills: Workflows reutilizables

Los skills son archivos markdown que ensenan al agente patrones especificos:

# Task Planning Skill

**Trigger**: User gives a complex task or asks to "implement", "build", "create"

## Before Starting ANY Complex Task

### 1. Understand the Goal
- What is the desired end state?
- What problem does this solve?
- What are the constraints?

### 2. Break Down the Task
**Bad**: "Build a login system"
**Good**:
1. Create user model with email/password
2. Implement password hashing
3. Create login endpoint
4. Add JWT token generation
5. Write tests for each component

### 3. Create a Todo List
Use write_todos to track the plan...

Los skills se cargan en el system prompt cuando son relevantes. El agente revisa el directorio skills/ y carga los skills que coinciden con el tema de la conversacion actual.

Gestion de contexto: Summarization + Persistencia

La arquitectura combina dos estrategias:

Corto plazo: Procesador de summarization - comprime automaticamente mensajes antiguos cuando el contexto se llena:

from pydantic_ai_summarization import create_summarization_processor

summarization_processor = create_summarization_processor(
    trigger=("fraction", 0.8),  # At 80% of context
    keep=("messages", 20),       # Keep last 20 messages
    max_input_tokens=128000,
)

Largo plazo: Memoria basada en archivos - el agente escribe hechos importantes en archivos markdown:

# When user says "My name is Kacper"
# Agent immediately calls:
edit_file("knowledge/user.md", old_string="", new_string="Name: Kacper\n")

El contexto de corto plazo (mensajes recientes) se gestiona automaticamente. La memoria de largo plazo (preferencias del usuario, detalles del proyecto) se gestiona intencionalmente por el agente.

Busqueda de historial: Encontrar sin cargar

Para conversaciones que abarcan cientos de mensajes, proporcionamos una herramienta de busqueda que consulta la base de datos sin cargar todo en el contexto:

@toolset.tool
async def search_history(query: str, limit: int = 10, role: str = None) -> str:
    """Search conversation history for past messages.

    The most recent 10 messages are already in your context.
    Use this for older messages or specific searches.
    """
    messages = await conversation_repo.search_messages(
        db, conversation_id, query,
        limit=min(max(1, limit), 50),
        role=role,
    )

    if not messages:
        return f"No messages found matching '{query}'"

    results = []
    for msg in messages:
        timestamp = msg.created_at.strftime("%Y-%m-%d %H:%M")
        content = msg.content[:500] + "..." if len(msg.content) > 500 else msg.content
        results.append(f"[{timestamp}] {msg.role.capitalize()}: {content}")

    return f"Found {len(messages)} message(s):\n\n" + "\n\n".join(results)

El agente puede buscar “Python tutorials” en mensajes antiguos sin cargar todo el historial de conversacion. Los resultados se truncan a 500 caracteres para evitar la inflacion del contexto.

El patron: Memoria selectiva > Memoria total

Aqui esta el framework:

Ventana de contexto (10-20 mensajes): Conversacion reciente, gestionada automaticamente por summarization
Memoria persistente (archivos): Hechos importantes guardados intencionalmente por el agente
Busqueda de historial (base de datos): Archivo buscable para consultas poco frecuentes
Skills (archivos): Workflows aprendidos cargados bajo demanda

Cada capa maneja diferentes necesidades de retencion. No haces embedding de cada mensaje en una base de datos vectorial. No almacenas cada hecho en un knowledge graph. Dejas que el agente decida que importa - igual que la memoria humana.

Conclusiones clave

Almacena menos, recuerda mejor. La mayoria de los sistemas de memoria almacenan todo y recuperan mal. La memoria selectiva e intencional supera a la memoria total siempre.
Ensena al agente sobre sus propias limitaciones. El system prompt debe decir explicitamente “tu contexto contiene 10 mensajes.” Sin esto, el agente asume que recuerda todo.
“Guardar inmediatamente” es la regla critica. Si el agente no guarda la informacion en el momento en que la aprende, la informacion se perdera cuando el contexto cambie. No hay segunda oportunidad.
La memoria basada en archivos es simple y depurable. Puedes leer los archivos de memoria del agente. Puedes editarlos. Puedes versionarlos con git. Intenta hacer eso con una base de datos vectorial.
Combina estrategias de corto y largo plazo. La summarization maneja el contexto reciente. La memoria basada en archivos maneja el conocimiento persistente. La busqueda de historial maneja consultas poco frecuentes. Cada capa sirve un proposito diferente.

Pruebalo tu mismo

memv - Sistema de memoria persistente para agentes AI con almacenamiento estructurado en archivos y retencion selectiva.

pip install memvee