Anthropic acaba de publicar un PDF de 13 páginas sobre memoria para agentes de IA
5 capas para reducir un 90% el coste en tokens y hacer que tu agente aprenda de verdad
1. MEMORIA DE TRABAJO: lo que ve ahora
La ventana de contexto. Todo lo que el agente tiene delante en este momento
Cuando se llena, el contexto antiguo se pierde. La mayoría de los agentes se quedan aquí y luego nos preguntamos por qué fallan
2. MEMORIA EPISÓDICA: lo que pasó
El historial completo de interacciones, con fecha y hora
El agente recuerda que el despliegue falló el martes a las 3 de la mañana porque el script de migración tenía una errata
No tienes que explicárselo otra vez
3. MEMORIA SEMÁNTICA: lo que sabe
Hechos, entidades y relaciones guardados en un grafo de conocimiento
«El usuario prefiere TypeScript» vive aquí
Y no desaparece cuando termina la sesión
4. MEMORIA PROCEDIMENTAL: cómo hacer las cosas
El agente prueba 3 enfoques. Uno funciona
Ese método se convierte en una habilidad reutilizable
La próxima vez va directamente a lo que funcionó
5. OLVIDO: lo que debe borrar
Un agente que nunca olvida acaba acumulando contradicciones
Las preferencias antiguas se imponen a las nuevas. Te mudas de ciudad y sigue recomendándote restaurantes donde vivías antes
Recordar importa. Saber qué olvidar, también
¿El resultado?
→ Mem0 almacena 1.800 tokens por consulta en lugar de 26.000
→ Snowflake añadió una capa de ontología: un 20% más de precisión y un 39% menos de llamadas a herramientas
La memoria compensa su coste desde el primer día
Este PDF de 13 páginas marca la diferencia entre un chatbot y un agente que aprende de verdad// un nodo con contrato real: entrada acotada, salida validada, un solo trabajo
const ITEM = {
type: 'object',
additionalProperties: false,
properties: {
titulo: { type: 'string' },
url: { type: 'string' },
impacto: { type: 'string', enum: ['alto', 'medio', 'bajo'] },
},
required: ['titulo', 'url', 'impacto'],
};
const salida = await agent(fuente.prompt, {
label: `research:${fuente.key}`,
schema: ITEM,
agentType: 'general-purpose',
});phase('Research');
const bruto = await parallel(
FUENTES.map((f) => () =>
agent(f.prompt, {
label: `research:${f.key}`,
phase: 'Research',
schema: ITEM,
agentType: 'general-purpose',
}),
),
);
const recogido = bruto.filter(Boolean); // fuera los null de los agentes caídos// la arista: JS plano, sin agente, cero tokens
const plano = recogido.flatMap((c) => c.items);
log(`Recogidos ${plano.length} elementos`);
phase('Curar');
// el nodo barrera: necesita el conjunto ENTERO para deduplicar y ordenar
const curado = await agent(
`Deduplica y ordena estos por impacto:\n${JSON.stringify(plano)}`,
{ phase: 'Curar', schema: CURADO },
);// nodo router: un agente clasifica, el código elige la arista
const { severidad } = await agent(
`Clasifica el riesgo de este diff:\n${diff}`,
{ schema: {
type: 'object',
properties: { severidad: { enum: ['baja', 'alta'] } },
required: ['severidad'],
}},
);
let revision;
if (severidad === 'alta') {
revision = await parallel(ARCHIVOS.map((a) => () => agent(`Audita ${a}`)));
} else {
revision = await agent(`Revisión rápida de ${diff}`);
}const visto = new Set();
const confirmados = [];
let secas = 0;
while (secas < 2) { // para tras 2 rondas vacías
const encontrados = (await parallel(
BUSCADORES.map((b) => () => agent(b.prompt, { schema: BUGS }))
)).filter(Boolean).flatMap((r) => r.bugs);
const nuevos = encontrados.filter((b) => !visto.has(clave(b)));
if (!nuevos.length) { secas++; continue; } // nada nuevo → hacia seco
secas = 0;
nuevos.forEach((b) => visto.add(clave(b))); // dedupe vs VISTO, no confirmados
const juzgados = await parallel(nuevos.map((b) => () =>
parallel(['correcto', 'seguridad', 'repro'].map((lente) => () =>
agent(`Juzga "${b.desc}" desde ${lente}. ¿Es real?`, { schema: VEREDICTO })))
.then((v) => ({ b, real: v.filter(Boolean).filter((x) => x.real).length >= 2 }))
));
confirmados.push(...juzgados.filter((v) => v.real).map((v) => v.b));
}
