Memory Layer: Cómo los agentes almacenan y recuperan memoria

Idea en 30 segundos

Memory Layer no es solo un almacen de hechos, sino una capa controlada de seleccion, escritura y devolucion de memoria.

El agente no debe enviar todo el historial en cada solicitud. Lee de memoria solo lo que realmente ayuda al siguiente paso. Memory Layer no debe acumular todo sin criterio. Su tarea es devolver poco, pero preciso.

Cuando se necesita: cuando el agente trabaja no en un paso, sino en una serie de pasos o sesiones donde importan consistencia y personalizacion. LLM no tiene acceso directo a side effects (cambios de estado). Solo propone tool_call, y el sistema decide si esa accion puede ejecutarse. LLM solo puede ver lo que entra en el contexto actual. Memory Layer decide que parte del pasado conviene traer de vuelta.

Problema

Sin una capa de memoria separada, el agente casi siempre trabaja "desde cero".

Esto crea problemas tipicos:

• el agente vuelve a preguntar lo que ya sabe;
• las respuestas se vuelven inconsistentes entre sesiones;
• entra demasiado historial irrelevante en el contexto;
• los hechos importantes se pierden en el ruido;
• en memoria se acumulan duplicados o versiones en conflicto del mismo hecho;
• el agente personaliza respuestas con datos obsoletos o debilmente sustentados.

Como resultado, aumentan costo, latencia y cantidad de errores en respuestas.

Solucion

Agregar Memory Layer como capa separada para memoria: que guardar, que devolver al contexto y que eliminar.

Separa la logica de "como recordar" de la logica de "como pensar", por eso el agente funciona mas estable.

Analogia: como notas de un manager sobre un cliente.

El manager no mantiene en la cabeza todo el archivo de conversaciones. Saca notas cortas relevantes: lo importante para esta conversacion.

Memory Layer hace lo mismo y devuelve al agente solo la memoria necesaria en el momento necesario.

Como Funciona Memory Layer

Memory Layer es una capa controlada entre Agent Runtime y memory store que decide que leer, que escribir y que limpiar.

Este ciclo se repite en cada paso y ayuda al agente a mantener consistencia entre pasos y sesiones.

En Codigo se Ve Asi

class MemoryLayer:
    def __init__(self, store, max_items_per_user=200):
        self.store = store
        self.max_items_per_user = max_items_per_user

    def retrieve(self, user_id: str, query: str, top_k: int = 4):
        # Devolver solo memoria relevante, no todo el historial.
        items = self.store.search(
            user_id=user_id,
            query=query,
            limit=top_k,
            min_score=0.7,
            exclude_expired=True,
        )
        return [item["text"] for item in items]

    def write(
        self,
        user_id: str,
        observation: str,
        tags: list[str],
        source: str = "user",
        sensitivity: str = "low",
        ttl_days: int = 30,
    ):
        if not self._worth_storing(
            observation=observation,
            tags=tags,
            source=source,
            sensitivity=sensitivity,
            ttl_days=ttl_days,
        ):
            return

        self.store.insert(
            user_id=user_id,
            text=observation,
            tags=tags,
            source=source,
            sensitivity=sensitivity,
            ttl_days=ttl_days,
        )
        self.store.enforce_limit(user_id=user_id, max_items=self.max_items_per_user)

    def _worth_storing(
        self,
        observation: str,
        tags: list[str],
        source: str,
        sensitivity: str,
        ttl_days: int,
    ) -> bool:
        text = observation.strip()
        if len(text) < 20:
            return False

        # No guardar frases de servicio cortas.
        if text.lower() in {"ok", "gracias", "hecho", "listo"}:
            return False

        # No escribir datos sensibles en memoria estandar.
        if sensitivity == "high":
            return False

        # Confiar solo en fuentes definidas.
        if source not in {"user", "tool", "policy"}:
            return False

        # La memoria debe ser estable y util, no ruido aleatorio.
        stable_tags = {"preference", "constraint", "profile", "goal"}
        if not any(tag in stable_tags for tag in tags):
            return False

        if ttl_days < 1 or ttl_days > 365:
            return False

        return True

Como se Ve Durante la Ejecucion

Solicitud: "Preparame un plan de alimentacion para la semana"

Step 1
Agent Runtime: llama a Memory Layer.retrieve(...)
Memory Layer: devuelve hechos relevantes -> ["alergia al mani", "dieta vegetariana"]
Agent Runtime: agrega estos hechos al Context
Agent Runtime: llama a LLM.decide(...)

Step 2
LLM: devuelve -> final_answer (plan sin mani ni carne)
Agent Runtime: pasa nueva observacion a Memory Layer.write(...)
Memory Layer: guarda hecho -> "usuario quiere presupuesto hasta $80/semana"

Memory Layer ayuda al agente a no olvidar lo importante y a no sobrecargar el contexto con detalles extra.

Cuando Encaja - y Cuando No

Memory Layer es util cuando el agente debe recordar hechos entre pasos o sesiones. Para solicitudes de una sola vez, suele ser innecesario.

Encaja

No Encaja

En estos casos suele bastar una llamada al modelo:

response = llm(prompt)

Problemas y Fallas Tipicas

La mayoria de problemas de Memory Layer se resuelven con reglas claras de escritura, buen ranking y control de acceso.

Como se Combina con Otros Patrones

Memory Layer no controla todo el agente. Solo responde por trabajo de memoria de calidad en cada paso.

• Agent Runtime — Runtime decide cuando consultar memoria, y Memory Layer decide que leer, escribir o eliminar.
• Tool Execution Layer — los tool calls pueden leer o actualizar memoria via capa controlada de ejecucion.
• Memory-Augmented Agent — este patron depende directamente de Memory Layer.
• RAG Agent — RAG obtiene conocimiento externo, mientras Memory Layer mantiene experiencia interna del agente/usuario.

En otras palabras:

• Agent Runtime define cuando el agente consulta memoria
• Memory Layer define que se guarda y que se devuelve

En Que se Diferencia de Agent Runtime

Agent Runtime es el "director" de todo el proceso.

Memory Layer es la "memoria del sistema" que mantiene consistencia en la respuesta.

Resumen

FAQ

Q: No alcanza con pasar todo el historial en el prompt?
A: Para escenarios cortos, a veces si. Pero en dialogos largos es caro, lento y ruidoso. Memory Layer da memoria breve y relevante en lugar del log completo.

Q: En que se diferencia memoria short-term de long-term?
A: Short-term sirve para el run o sesion actual. Long-term guarda hechos importantes entre sesiones y se reutiliza luego.

Q: Se puede guardar en memoria cada paso del agente?
A: Tecnicamente si, pero es mala practica. Mejor guardar solo hechos utiles con reglas de escritura; de otro modo la memoria se vuelve ruido rapido.

Q: Memory Layer reemplaza RAG o tool calls?
A: No. Memory Layer guarda hechos internos y experiencia del agente/usuario. Para datos externos frescos, normalmente hacen falta retrieval o tool calls.

Que Sigue

La memoria solo sirve cuando se mantiene bajo control. El siguiente paso es ver donde memoria se conecta con ejecucion y policy:

• Agent Runtime - como runtime integra memoria en cada iteracion.
• Multi-Tenant - como evitar mezclar contexto y datos entre clientes.
• Policy Boundaries - como restringir acceso a memoria sensible.
• Production Stack - como combinar calidad de memoria, auditoria y control operativo.