How TencentDB Agent Memory Enables Agents to Reason, Not Just Remember

TencentDB Agent Memory transforms raw conversation logs into structured, reusable knowledge assets that agents actively apply during reasoning rather than simply retrieving verbatim history.

TencentDB Agent Memory is an open-source framework maintained by TencentCloud that elevates agent memory from passive storage to an active reasoning substrate. Instead of treating memory as a warehouse of past conversations, the system structures experience into four distinct asset types—Chat Memory, Skills, Wiki, and CodeGraph—each stored in layered representations and served on-demand through a unified injection pipeline.

Structuring Experience into Memory Assets

The architecture distinguishes between four memory asset types, each designed to improve specific aspects of agent reasoning.

Layered Memory: From Raw Logs to Reasoning Context

The system implements a four-tier abstraction (L0→L3) that progressively distills experience into higher-value representations. According to /feat/server_team/README.md (lines 78-85), raw conversations are preserved as L0 snapshots, then processed into factual extracts (L1), scenario summaries (L2), and long-term personas (L3).

This hierarchy allows agents to bootstrap quickly with high-level context from L2/L3 while retaining the ability to drill down to precise L0 facts when specific details matter. The cognitive benefit is significant: an agent starts a new task already equipped with the gist of prior work, reserving inference bandwidth for novel problem-solving rather than re-learning context.

Chat Memory: Cross-Session User Understanding

Chat Memory captures user preferences, decisions, and interaction history across sessions. As documented in /feat/server_team/README.md (lines 96-100), this asset prevents the need to re-ask for established details, allowing the model to focus computational resources on solving the current problem rather than reconciling duplicated information.

Skills Library: Executable Workflows

The Skills asset transforms tacit procedural knowledge into versioned, executable workflows extracted from past conversations. The implementation in /feat/server_team/README.md (lines 106-110) shows how successful task completions are converted into reusable snippets. When a new task matches a known pattern, the agent invokes the corresponding Skill instead of rediscovering the solution, dramatically reducing token consumption and error rates.

Wiki and CodeGraph: Structured Knowledge and Impact Analysis

Wiki provides a searchable knowledge graph of design documentation and operational specifications (lines 118-122), enabling agents to look up exact APIs or constraints on-demand. CodeGraph indexes symbols, call relationships, and impact paths (lines 122-124), allowing agents to reason about side effects before applying code changes—understanding that "changing this might affect those" rather than blindly applying edits.

The Injection Pipeline: Delivering Context Without Noise

The technical implementation centers on a pure-function pipeline that decouples asset preparation from request handling.

Request Classification and Session Management

Located in /feat/server_team/MemoryProxy/src/workbuddyHandler.ts, the classifyWorkbuddyRequest function (lines 26-33) distinguishes between "main" requests and "auxiliary" calls (such as /compact or /trace_summarize). This classification prevents irrelevant memory from contaminating the LLM's reasoning context during administrative operations.

import { classifyWorkbuddyRequest } from "./src/workbuddyHandler.ts";

const kind = classifyWorkbuddyRequest(
  body,                // request JSON payload
  path,                // request URL path
  headers,             // lower-cased header map
);                     // → "main" | "auxiliary"

The extractWorkbuddySessionId function (lines 61-73) ensures stable session tracking, falling back to generated keys when necessary. This stability allows the Memory Hub to retrieve the correct asset bundle for each conversation.

import { extractWorkbuddySessionId } from "./src/workbuddyHandler.ts";

const sessionId = extractWorkbuddySessionId(headers, body);
// Fallback to a generated key if missing → ensures every turn is traceable.

Asset Injection via <tdai_injections>

The injectWorkbuddyAssets function (lines 21-35) wraps relevant context in a <tdai_injections> XML tag, inserting the content directly into the LLM's first user message. This approach provides a concise, relevant context block that guides the model's chain-of-thought rather than overwhelming it with irrelevant chatter.

import { injectWorkbuddyAssets } from "./src/workbuddyHandler.ts";

const enrichedBody = injectWorkbuddyAssets(body, {
  raw: "<tdai_injections>" + sessionContextBlock + "</tdai_injections>",
});

Continuous Learning Through L0 Writes and Skill Extraction

After each turn, triggerWorkbuddyArchiveHooks (lines 81-89 and 100-108) persists the user-assistant pair to long-term L0 storage and triggers the skill-extraction engine. This creates a feedback loop where the knowledge base grows cumulatively, providing later agents with richer priors for reasoning.

import { triggerWorkbuddyArchiveHooks } from "./src/workbuddyHandler.ts";

await triggerWorkbuddyArchiveHooks(archiveCtx, assistantText, toolUseCount);

The system also integrates Langfuse observability (lines 64-68 and 470-474) to monitor streams, report usage, and track turn sequences, enabling engineers to identify reasoning failures and improve asset generation pipelines.

Summary

• TencentDB Agent Memory structures raw experience into four actionable asset types: Chat Memory, Skills, Wiki, and CodeGraph.
• The L0-L3 layered architecture distills conversations from raw logs to high-level personas, enabling agents to bootstrap with relevant context.
• The injection pipeline in workbuddyHandler.ts uses request classification and the <tdai_injections> wrapper to deliver precise context without noise.
• Skills extraction converts successful workflows into reusable, versioned assets that prevent agents from rediscovering known solutions.
• CodeGraph integration enables impact analysis, allowing agents to reason about side effects before modifying code.

Frequently Asked Questions

How does TencentDB Agent Memory differ from simple vector storage of chat history?

Unlike vector databases that retrieve similar text chunks, TencentDB Agent Memory structures experience into semantically distinct asset types with specific reasoning functions. The L0-L3 layering converts raw logs into facts, scenarios, and personas, while the injection pipeline delivers only relevant assets via the <tdai_injections> wrapper. This provides agents with actionable knowledge rather than requiring them to parse through raw conversation text.

What triggers the conversion of conversations into Skills?

The triggerWorkbuddyArchiveHooks function in /feat/server_team/MemoryProxy/src/workbuddyHandler.ts (lines 81-89) executes after each assistant turn, persisting the interaction to L0 storage and invoking the skill-extraction engine. When the system detects a reusable workflow pattern in the conversation history, it versions and stores it as an executable Skill that future agents can invoke directly.

How does the system prevent memory from overwhelming the LLM's context window?

The classifyWorkbuddyRequest function distinguishes between "main" and "auxiliary" requests, bypassing injection for administrative calls like /compact. For main requests, the injection pipeline selects only relevant assets from the Memory Hub and wraps them in the concise <tdai_injections> block. This ensures the LLM receives high-signal context rather than the full corpus of historical data.

Can agents from different teams access the same memory assets?

The Memory Hub control panel (/feat/server_team/README.md, lines 129-136) provides team-based access controls (ACLs) that bind specific assets to specific agents. While assets can be shared across teams through explicit configuration, the default architecture ensures agents only see the memory assets they need. This reduces noise and prevents unrelated data from interfering with the reasoning process.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}