Memoria estructurada para agentes de IA: la técnica que ganó 6 de 10 partidas en Slay the Spire 2
Investigadores del proyecto AgenticSTS sustituyeron los interminables logs de conversación por 5 capas de memoria independientes. El resultado: su agente pasó de 0 a 6 victorias en el juego de cartas Slay the Spire 2 mientras otros agentes seguían atascados en cero. Hoy te enseño cómo funciona esta arquitectura y cómo aplicarla a tus propios agentes.
En resumen
- Investigadores reemplazaron los logs de chat infinitos por 5 capas de memoria separadas y el agente pasó de 0 a 6 victorias. Así funciona y cómo aplicarlo.
- Personalmente creo que el hallazgo de AgenticSTS es uno de los más infravalorados de 2026.
- Cuando construyes un agente de IA que toma decisiones durante cientos de turnos, el enfoque más común es mantener un historial de conversación acumulativo.
🧩 Caso 1: El problema del chat log infinito
Cuando construyes un agente de IA que toma decisiones durante cientos de turnos, el enfoque más común es mantener un historial de conversación acumulativo. Cada decisión, cada observación y cada resultado se van apilando en el prompt.
El resultado es predecible: tras 300 turnos, el prompt puede superar los 500.000 tokens. Aunque modelos como GPT-4o o Claude Opus tienen ventanas de contexto de 200K-500K tokens, el problema no es solo la capacidad técnica — es que el modelo pierde el foco. Las decisiones del turno 300 acaban influenciadas por ruido del turno 12 que ya no es relevante.
En el paper AgenticSTS (arXiv:2607.02255), los investigadores documentan que cinco configuraciones previas de agentes con LLM obtuvieron cero victorias en la dificultad más baja de Slay the Spire 2. Mientras tanto, un humano medio gana el 16% de las partidas. Algo estaba fundamentalmente roto.
🧩 Caso 2: La arquitectura de 5 capas de memoria
La solución de AgenticSTS fue radical: en lugar de un único historial que crece sin control, dividieron la memoria en cinco almacenes independientes con propósito específico. Según The Decoder y el análisis de Let's Data Science, estas son las cinco capas:
- Memoria estratégica: el plan general de la partida — qué tipo de mazo estoy construyendo, qué arquetipo persigo.
- Memoria táctica: el estado inmediato del combate — qué cartas tengo en la mano, cuánta energía me queda, qué va a hacer el enemigo este turno.
- Memoria de observaciones: registro comprimido de lo que ha pasado — enemigos derrotados, reliquias obtenidas, eventos del mapa.
- Memoria del mazo: qué cartas tengo, cuáles he mejorado, cuáles he eliminado.
- Memoria de decisiones: qué funcionó y qué no en situaciones similares anteriores dentro de la misma run.
Cada capa se consulta mediante recuperación tipada (typed retrieval): el agente no vuelca toda la memoria en el prompt, sino que pregunta «dame las cartas que tengo en la mano ahora mismo» o «¿qué enemigos he derrotado que usaban veneno?». El prompt se mantiene en torno a 5.000 tokens — dos órdenes de magnitud menos que el enfoque tradicional.
El código está disponible en GitHub: STS2MCP. Usa el Model Context Protocol (MCP) para exponer el estado del juego como herramientas que el agente puede consultar.
🧩 Caso 3: Implementa memoria estructurada con Mem0 (código real)
No necesitas construir un agente para Slay the Spire para aplicar esto. La misma arquitectura funciona para agentes de atención al cliente, asistentes de código o bots de automatización. Aquí te muestro cómo hacerlo con Mem0, el framework open-source que en 2026 se ha convertido en el estándar de facto para memoria de agentes, con soporte para 21 frameworks y 20 vector stores, según su reporte anual.
pip install mem0ai openai
from mem0 import Memory
# Inicializar Mem0 con 3 capas de memoria independientes
m = Memory()
# 1. Memoria a largo plazo: hechos persistentes
m.add("El cliente prefiere respuestas en español neutro",
user_id="cliente-42",
metadata={"type": "preferencia", "scope": "idioma"})
# 2. Memoria episódica: historial de interacciones
m.add("El 10 julio preguntó sobre facturación de julio —
se resolvió con reembolso parcial",
user_id="cliente-42",
metadata={"type": "episodio", "fecha": "2026-07-10"})
# 3. Consulta tipada: solo recuperar lo relevante
resultados = m.search(
"facturación julio",
user_id="cliente-42",
filters={"type": "episodio"} # Solo memoria episódica
)La clave es el filtro por metadatos que Mem0 introdujo en su versión 1.0.0. Según explican en el State of AI Agent Memory 2026, antes de esta feature la búsqueda era puramente semántica. Ahora puedes poner atributos como {"context": "soporte_facturacion"} y el agente solo recupera memorias de ese dominio. Es exactamente el mismo principio que usa AgenticSTS con sus capas tipadas.
Yo mismo he probado este enfoque en un agente de soporte para La Frontera IA y la diferencia es brutal: sin filtros, el agente mezcla información de facturación con preguntas sobre artículos. Con filtros por tipo de memoria, las respuestas son mucho más precisas.
🧩 Caso 4: Frameworks alternativos — el ecosistema de memoria en 2026
Mem0 no es la única opción. En 2026 hay al menos 8 frameworks serios para memoria de agentes. Según la comparativa de Vectorize y MachineLearningMastery, aquí tienes los más relevantes:
- Zep (getzep.com): Grafos temporales de contexto. En lugar de embeddings planos, modela relaciones entre hechos a lo largo del tiempo. Ideal para agentes que necesitan trackear cambios de estado.
- Letta: Memoria persistente con «bloques de memoria» editables. El agente puede literalmente reescribir sus recuerdos, no solo añadir.
- Hindsight: Optimizado para agentes que operan en entornos cambiantes. Detecta automáticamente cuándo una memoria se ha vuelto obsoleta.
- Cognee: Enfocado en grafos de conocimiento. Si tu agente necesita razonar sobre cómo se relacionan las entidades entre sí, este es tu framework.
DeepLearning.AI tiene un curso gratuito de Andrew Ng sobre memoria de agentes que cubre exactamente cómo implementar un Memory Manager que orqueste lecturas, escrituras y recuperación durante la ejecución del agente. Si quieres profundizar, es el mejor punto de partida.
🧩 Caso 5: Resultados — de 0 a 6 victorias, y lo que significa para tus agentes
El dato más impactante del paper es este: al añadir la capa de memoria táctica (la que gestiona el estado inmediato del combate), el agente pasó de 3 de 10 a 6 de 10 victorias. Es una mejora del 100% con un solo cambio arquitectónico. AI Weekly reporta que la significación estadística es direccional (Fisher p≈0.37), no concluyente — pero la tendencia es clara.
Lo que esto demuestra no es que los LLMs sean buenos jugando a cartas. Lo que demuestra es que el cuello de botella no es el modelo, es cómo gestionas su memoria. Un agente con Claude o GPT-4o usando logs infinitos pierde siempre. El mismo modelo con memoria estructurada gana el 60% de las partidas.
Según la guía práctica de Fountain City, la arquitectura recomendada para producción en 2026 es exactamente esta: memoria de dos niveles con una capa rápida (en RAM o Redis) para el contexto inmediato y una capa lenta (vector store) para conocimiento histórico, más extracción/actualización/borrado periódico para evitar que los datos se corrompan con el tiempo.
Personalmente creo que el hallazgo de AgenticSTS es uno de los más infravalorados de 2026. Todo el mundo habla de modelos más grandes y contextos más largos, pero el paper demuestra que con 5.000 tokens bien organizados consigues resultados que 500.000 tokens desordenados no pueden igualar.
Lo que hemos aprendido
La lección de Slay the Spire 2 es aplicable a cualquier agente que tomes decisiones secuenciales: no tires todo al prompt. Separa la memoria en capas con propósito, usa recuperación tipada en lugar de búsqueda semántica genérica, y manten el contexto de trabajo por debajo de 10.000 tokens. Las herramientas existen (Mem0, Zep, Letta), los cursos están ahí (DeepLearning.AI), y los resultados hablan solos: 0 a 6 victorias no es un incremento incremental — es pasar de inútil a funcional.
Si estás construyendo agentes en 2026, la pregunta ya no es «¿qué modelo uso?». La pregunta es «¿cómo estructuro su memoria?».