Add a second or third coding agent to a team's workflow and a specific waste shows up fast: every new session re-explains the same project context, re-reads the same docs, and rediscovers a workflow that already worked last week. TencentDB Agent Memory, built by Tencent Cloud, is aimed squarely at that waste — not memory for a single agent's own conversation history, but a shared, governed memory layer an entire team of agents and humans can draw from, so what one agent learns doesn't die with its session.
Four Kinds of Memory, Not One
The core design decision is refusing to treat "memory" as one undifferentiated pile of past conversations. Four distinct asset types get automatically extracted from actual work:
| Asset | What it captures |
|---|---|
| Chat Memory | Preferences, decisions, and interaction history, extracted in layers across sessions |
| Skill | A reusable SOP distilled from a task that actually worked — versioned, with trigger conditions and verification rules |
| Wiki | Documents turned into structured, linked pages — explicitly inspired by the practice of building a navigable knowledge base rather than a flat document dump |
| CodeGraph | An index of a repository's symbols, files, and call relationships, so an agent can check the impact of a change before making it |
Treating these as four separate, first-class asset types rather than one memory blob is what makes the system genuinely useful across different kinds of work — a Skill and a Wiki page serve completely different retrieval needs, and collapsing them into one undifferentiated memory store is exactly the pattern that makes most "AI memory" features shallow in practice.
Memory That Grows in Layers, Not Flat Records
Chat Memory specifically doesn't get stored as one flat log. Conversations are saved raw as L0, then an async pipeline refines them upward: L1 extracts atomic facts, preferences, and events; L2 organizes knowledge around specific projects or scenarios; L3 synthesizes long-term profiles and stable patterns. Retrieval mirrors that structure — L2/L3 give a fast context bootstrap for the common case, and the system falls back to BM25 plus vector retrieval with reciprocal rank fusion against L1/L0 when a specific fact actually needs verifying, with results capped by item count, character budget, and timeout so memory can't quietly overwhelm the context window. That's a meaningfully more deliberate design than dumping recent history into a prompt and hoping relevance sorts itself out.
Governance Is the Actual Product, Not an Add-On
The Memory Hub is explicitly built as a control panel, not a passive log viewer. Assets are owned by a Team or Agent, tracked by version and status, and governed by three visibility tiers — private, team, and restricted, the last enforced through a full user/role/agent ACL — plus a separate "Agent Loadout" mechanism that lets an operator decide which specific assets a given agent is equipped with and at what priority. That's the part worth taking seriously for any real team deployment: shared memory without access control just means every agent can read everything, which is a real information-boundary problem the moment agents are working across clients, projects, or sensitivity levels. Fixed Binding plus ACL narrows what's retrievable before a query even runs, rather than filtering after the fact.
A Real Benchmark, Not Just a Feature List
Tencent publishes a concrete result rather than only a feature list: on PersonaMem, a benchmark specifically testing whether an agent correctly understands and applies user information after extended interaction, scores went from 48% without the system to 76% with it enabled — a 59% relative improvement. That's a specific, falsifiable claim rather than marketing language, and it's the kind of benchmark worth re-running against your own workload before trusting it wholesale, the same way you'd treat any vendor-published number.
Cold Start: Importing What Already Exists
The system is explicitly built around the idea that a new agent's first task is usually re-learning a project that's already been learned once. Rather than starting every new agent or team from a blank memory store, the Hub accepts three kinds of import and turns each into the matching asset type automatically: existing codebases get indexed into CodeGraph, relevant documents and files get turned into structured Wiki pages, and past agent conversation sessions get mined for reusable Skills and Chat Memory. The framing in Tencent's own documentation is direct about the goal — stop retraining every agent from scratch, and give it the save file instead. That's a meaningfully different starting posture than most memory tooling, which typically only starts capturing value going forward from the moment it's installed.
What a Team Actually Looks Like in Practice
Tencent's documentation illustrates the team-ownership model with a concrete example worth understanding on its own terms: a one-person company assembling a small squad of role-scoped agents — a Scout for research and market opportunities, a Builder for writing code and shipping product, a Reviewer for testing and catching issues, and an Agent Memory role for preserving what the team learns — with a human setting goals and making decisions. The point of the example isn't the specific roles; it's the "recruit first, then equip" pattern underneath it: each agent gets bound to a different loadout of memory assets — the Reviewer gets historical incident Chat Memory, project CodeGraph, and a release-checklist Skill, while the Scout gets user-interview Chat Memory, market-research Wiki, and a competitive-analysis Skill — so a growing team of agents doesn't all read from the same undifferentiated pile. That's the ACL and Agent Loadout machinery described above, applied to an actual scenario instead of described abstractly.
How This Differs From Standard RAG
It's worth being precise about what problem this solves that a standard retrieval-augmented-generation setup doesn't, since "AI memory" gets used loosely enough to mean very different things. Plain chat history and standard RAG both answer "what can be found" reasonably well, but neither tracks ownership, versioning, or who's allowed to see what, and neither distills a workflow that worked into something reusable — RAG chunk-retrieves against documents, it doesn't turn a document into a structured, linked Wiki page, and it doesn't turn code into a call-graph an agent can run impact analysis against before editing. TencentDB Agent Memory's four-asset model is built specifically to answer the questions plain retrieval leaves open: which version of a fact is current, which agent is equipped with it, and whether it's private, team-visible, or restricted by ACL.
How Agents Actually Connect to It
A Memory Proxy component is what lets an existing coding agent — Claude Code and others — use team memory without a bespoke integration: it speaks both Anthropic and OpenAI-compatible protocols, walks a user through selecting a team/agent/task on first use, and then injects the relevant L2/L3 memory, matched skills, and wiki or code-graph context directly into the system prompt on every turn, authenticated per-user so asset visibility stays scoped correctly. Deployment is a three-container Docker setup (memory-core, memory-hub, memory-proxy) with a single start-all.sh script, and official SDKs ship for both TypeScript and Python.
What to Weigh Before Adopting It
- This is genuinely for teams, not solo use. The entire design — ACLs, team ownership, agent loadouts — assumes more than one agent or person is sharing memory. A single-agent setup won't see the actual value this architecture is built for.
- CodeGraph currently favors public HTTPS repos. Private repository and SSH credential support is explicitly still being refined per the project's own notes — worth checking current status before depending on it for a private codebase.
- Wiki and CodeGraph build asynchronously. Assets aren't instantly ready after ingestion; plan for processing time before an agent can actually query newly indexed docs or code.
- License terms are worth reading directly — GitHub's automated license detection flags this as a non-standard license despite an MIT badge in the README, which is worth resolving by reading the actual
LICENSEfile rather than trusting either signal alone.
Practical Takeaway
TencentDB Agent Memory is a serious answer to a problem that gets worse, not better, as teams add more agents: without a shared, governed memory layer, every new agent session starts from zero and every team member's context lives in their own head. The layered memory model and asset-based governance are the parts most worth studying even independent of adopting the whole platform — they're a real, transferable pattern for anyone building agent memory systems or team-shared knowledge graphs from scratch.
Teams building shared memory, knowledge-graph retrieval, or governed multi-agent infrastructure can get hands-on architecture help from Woyce Technologies.
FAQ
What is TencentDB Agent Memory?
TencentDB Agent Memory is an open-source memory hub from Tencent Cloud that extracts four types of reusable memory assets — Chat Memory, Skill, Wiki, and CodeGraph — from a team's conversations, documents, and code, and shares them across multiple AI agents with access control.
How is this different from a single agent's chat history?
It's built for teams, not one conversation. Memory assets are owned, versioned, and access-controlled at the team level, and can be shared across multiple agents and frameworks rather than living inside one agent's isolated session history.
What are the four memory asset types?
Chat Memory (layered conversation history and preferences), Skill (reusable, versioned task procedures), Wiki (structured, linked documentation), and CodeGraph (an indexed map of a codebase's symbols and call relationships for impact analysis).
How does access control work?
Through three visibility tiers — private, team, and restricted, the last enforced by a full user/role/agent access-control list — combined with an "Agent Loadout" system that determines which specific assets a given agent can use and at what priority.
Can I connect Claude Code to TencentDB Agent Memory?
Yes — a Memory Proxy component speaks both Anthropic and OpenAI-compatible API protocols and injects relevant memory, matched skills, and knowledge-graph context directly into the system prompt on each turn.
Is TencentDB Agent Memory free to use?
It's open source and self-hostable via a three-container Docker deployment. License terms are worth confirming directly from the repository's LICENSE file, since automated license detection and the README's displayed badge don't fully agree.
How is this different from a standard RAG setup?
Standard RAG answers "what can be found" through chunk retrieval against documents. TencentDB Agent Memory also tracks who owns an asset, which version is current, and which agent is allowed to use it — plus it distills conversations into reusable Skills and code into a queryable call-graph, neither of which a typical RAG pipeline over raw documents does on its own.
Can I import an existing codebase and document set instead of starting from zero?
Yes — this is the system's stated "cold start" design. Existing repositories can be imported directly into CodeGraph, documents and files into Wiki, and past agent conversation sessions get mined automatically for Skills and Chat Memory, so a new agent team can start from accumulated experience rather than an empty memory store.
What's new in the current release?
Version 2.0.0, published August 2026, added forced Skill archiving so key procedures aren't lost, scheduled automatic CodeGraph re-sync after a repository changes, bilingual (English/Chinese) support in the Memory Hub panel, and expanded admin asset-management capability for system administrators.