The Real Promise—and Boundary—of Agent Memory

TencentDB Agent Memory answers a practical question: can an Agent’s accumulated experience become reliable help for the next task without becoming an unscoped archive or an oversized prompt? This final judgment connects the repository’s capture pipeline, layered memory, retrieval policy, Proxy lifecycle, governed loadouts, Skills, Wiki, CodeGraph, and deployment modes. It also states the conditions under which the promise holds and the points where the available evidence stops.

The answer is conditional. The system does more than save chat transcripts: it preserves raw interaction evidence, derives structured and scene-level views, ranks relevant material, places it into a protocol-correct session, and records new work for later reuse. But each transition can be delayed, scoped, degraded, or wrong. Accumulation becomes useful only when the system can preserve the right evidence, attach it to the right identity, expose it at the right depth, and give people a way to correct or withhold it.

The unit of value is a governed transition

The repository’s strongest idea is not any individual storage backend or retrieval algorithm. It is the chain that turns work into a future starting point. A user and Agent complete a meaningful interaction. The Proxy extracts the real user request instead of the surrounding harness noise and writes the completed turn to L0. Core can then filter and structure that evidence into L1 records, consolidate related records into L2 scenes, and generate L3 profile or operating context. On a later turn, recall chooses a bounded subset, the session identity determines its scope, and the Proxy places the result into the client’s request or leaves deeper material behind a tool.

Each transition answers a different question. L0 asks, “What evidence of the exchange should remain available?” L1 asks, “Which durable fact, event, instruction, or work record can stand alone?” L2 asks, “How do related records form a coherent scene?” L3 asks, “What compact orientation helps the next Agent begin?” Retrieval asks, “Which of these views is relevant now?” Governance asks, “Who may receive it, and under which Agent?” A system that skips any of these questions may still produce a fluent answer, but it cannot explain why that answer inherited the right experience.

This is why the four asset types matter. Chat Memory carries continuity across sessions. Skill carries a repeatable procedure. Wiki carries structured reference to documents. CodeGraph carries relationships in a repository. They can support the same task from different directions. Consider a change to a login flow. Chat Memory may preserve the team’s decision to keep a legacy module. A Skill may describe the approved review and test sequence. Wiki may contain the design rationale. CodeGraph may show callers and impact paths. The Agent does not need all four in every turn; it needs the one that matches the question and the current loadout.

That matching is not just a matter of semantic similarity. A private memory can be more relevant than a shared one and still be correctly excluded. A Skill can be readable but not appropriate to bind to another Agent. A CodeGraph can contain the right symbol while reflecting an older repository snapshot. A scene can summarize the issue while leaving exact wording in L0. Reuse is therefore a governed transition from stored material to context, not a direct pipe from “nearest text” to “model instruction.”

The system’s separation of stable and dynamic context completes the chain. L3 and L2 navigation can provide a stable orientation. Current L1 results can be added dynamically for the user’s question. L0, full scenes, Wiki pages, and CodeGraph explorations can be fetched when precision or breadth is needed.