TencentDB Agent Memory v2: Team Hub for Chat, Skills, Wiki, CodeGraph

Agents remember. Humans innovate. — and Tencent just open-sourced the save file.

In August 2026, TencentDB Agent Memory shipped v2.0.0: a MIT-licensed team memory hub (~11.8K GitHub stars at write-up) that treats memory as governed assets, not a chat dump. Four types — Chat Memory, Skills, Wiki, CodeGraph — with a human-controlled Memory Hub for teams, ACLs, and Agent loadouts. Compatible with OpenClaw, Hermes, Claude Code, CodeBuddy, and SDKs.

The practical question they started from is the one every Claude Code shop hits: if we already explained the auth module once, why is the next session paying that tax again?

TL;DR

Quick start (v2)

git clone https://github.com/TencentCloud/TencentDB-Agent-Memory.git
cd TencentDB-Agent-Memory/deploy/global-images
cp .env.example .env
# Fill two LLM groups: memory + proxy
./start-all.sh   # prints a one-liner for Claude when ready

Open http://localhost:8125. Full install (standalone Hub, Proxy + Claude Code / CodeBuddy, ports, stop/cleanup): INSTALL.md. Migrating from v1/v0: use their Data Migration Tool (v2 → v3) docs.

Expect two LLM parameter groups in .env: one for the memory pipeline (extraction, distill, Wiki/CodeGraph jobs) and one for the proxy path Agents actually talk through. That split is intentional — you can run a cheaper model for async distill and a stronger model for interactive proxy without forcing every background job onto Opus-class pricing.

Repo layout mirrors the product: MemoryCore, MemoryKnowledge, MemoryPanel, MemoryProxy, plus deploy/, sdk/memory-core, and bilingual INSTALL/README. v2.0.0 is the first non-beta packaging of that stack after the mid-July v2.0.0-beta.1 line — treat the release notes and CHANGELOG as the migration map if you were on beta volumes.

Cold start: import the save file

Most agent “onboarding” is re-reading your repo and re-asking who owns auth. Tencent’s cold-start story is blunt: pay the learning tax once, then load the save file.

In the panel you can import:

That is closer to “boot a new teammate from the company vault” than to “paste more RAG chunks into every prompt.” New Agents inherit curated assets instead of burning the first fifty turns on rediscovery.

The four Memory Assets

Tagline from the README comparison table: RAG answers what can be found? Team Memory also answers who can use it, which version is valid, and which Agent gets it.

That maps cleanly onto explainx.ai’s agent skills and Karpathy LLM wiki / agent memory coverage — Tencent is productizing the ops layer (Owner, version, status, usage counts, bindings) that hobby wikis usually skip.

Skills as assets, not prompt paste

A Skill in this system is closer to a reviewed playbook than a SKILL.md you dropped in a folder: versions, resource files, trigger boundaries, execution steps, validation rules. Personal Skills stay private by default; after review they can be shared and bound to other Agents. That governance story matters if you have ever watched a “helpful” skill silently rewrite team conventions.

If you already maintain skills on explainx.ai’s /skills surface or follow skills vs hooks vs prompts, treat Tencent Skills as the team registry layer — where ownership and Agent bindings live — not a replacement for writing good skill markdown.

Wiki + CodeGraph: read less, hit harder

Wiki borrows the Karpathy “LLM-maintained knowledge base” idea: structured pages and a link graph so Agents drill by relationship instead of listing every file. CodeGraph answers the edit-time question RAG usually fails: if I change this symbol, what else moves? Agents discover capabilities through /v3/tools/list and pull pages or impact paths with /v3/tools/call — knowledge stays a tool call, not a mandatory context dump.

Memory Hub = control panel, not a museum

Visibility semantics (important):

New Chat Memory and Skills default to private. Sharing is an action, not a leak. That is the right default for “one-person company” multi-agent cosplay and for real orgs.

One-person company playbook (their framing)

Tiny but Serious Inc.
├── You · goals / decisions
├── Scout · research · interview Chat Memory + market Wiki + analysis Skill
├── Builder · product Wiki + CodeGraph + delivery Skill
├── Reviewer · incident Chat Memory + CodeGraph + release checklist Skill
└── Agent Memory · preserve team experience

Recruit first, then equip — different loadouts, less noise. Same idea as Hermes/OpenClaw squads, with a shared save file instead of four amnesiac chat windows. Pair with Hermes vs OpenClaw if you are choosing the runtime; Memory Hub sits above both as the shared experience plane.

Roles and ownership

Two role layers show up in the Hub docs: System Admin (users, teams, and full asset tooling) and team Admin / Member for collaboration inside a team. Asset Owner tracks who can manage a given Chat Memory, Skill, Wiki, or CodeGraph entry. That is the difference between a shared Google Doc chaos folder and something you can audit when an Agent starts citing a stale release checklist.

Technical spine (what actually matters)

1. Layered memory, not a flat store

Generation and retrieval are layered: L2/L3 bootstrap context; need a fact → BM25 + vectors + RRF into L1/L0. Caps on item count, characters, and timeouts keep memory from eating the context window — the same discipline as thin prompts / thick artifacts.

2. Loadout, not a global mega-prompt

Assets register uniformly. Hub uses Fixed Binding + ACL: narrow by Team/User/Agent/visibility, then retrieve for the query. Switch frameworks by re-equipping, not retraining.

3. Tools on demand

Wiki pages and CodeGraph are discovered via /v3/tools/list and pulled with /v3/tools/call — knowledge as callable tools, not dumped wholesale into every turn.

Acknowledgements in-repo: CodeGraph foundations, Hermes Agent skill code, Karpathy’s LLM Wiki idea. That pedigree is honest and useful for builders who already run those stacks.

What “every loop gains experience” means in practice

Memory does not replace the agent loop — it makes the next loop inherit the last loop’s residue. Valuable chat becomes Chat Memory; proven workflows become Skills; doc and code drift get re-ingested into Wiki and CodeGraph. Without that inheritance, loop engineering just accelerates amnesia. With it, Scout’s interview notes can load into Builder’s delivery Skill without pasting Slack threads by hand.

Compare to flat MEMORY.md or a single Obsidian vault: those are excellent personal persistence patterns. TencentDB Agent Memory is aimed at multi-Agent, multi-human governance — ACL, versions, loadouts — when the squad grows past one laptop.

Benchmarks and honest caveats

Reproduce PersonaMem before you put it on a slide. Treat v2 as production-curious: star count and PR volume (~410 open PRs noted on the GitHub UI at scrape time) signal heat and unfinished edges.

How it fits the rest of the stack

Without memory, agent loops just repeat faster. With inherited assets, each loop can compound — their diagram’s point.

TencentDB Agent Memory v2 checklist
□ start-all.sh + panel :8125
□ Import one repo → wait for CodeGraph ready
□ Import docs → Wiki link graph
□ Import a past Claude/OpenClaw session → Skills + Chat Memory
□ Create Scout/Builder/Reviewer Agents with different loadouts
□ Keep sensitive Chat Memory private; share Skills only after review
□ Paste proxy one-liner into Claude Code
□ Re-run PersonaMem yourself before citing 76%
□ Plan v1→v2 migration if you have old volumes

Honest limitations

• Vendor PersonaMem numbers need independent reproduction.
• Automated memory routing incomplete.
• Private git auth still catching up.
• Two LLM env groups to configure — ops cost is real.
• “Team memory” without process still becomes a junk drawer; Hub governance is mandatory.
• Stars move fast — re-check Releases for patches after v2.0.0.

Closing

TencentDB Agent Memory v2 is the most complete open team memory control plane we have seen in this wave: four asset types, ACL loadouts, cold-start imports, and Claude/OpenClaw/Hermes hooks. Star it if you are tired of re-explaining the auth module. Govern it if you actually deploy it.

Follow @explainx_ai as Team Memory Beta hardens automated routing and private-repo CodeGraph.

Related on explainx.ai

• Agent Reach — internet capability layer for agents
• Microsoft Generative AI for Beginners
• Karpathy LLM Wiki agent memory pattern
• Obsidian vault as agent memory graph
• What is MEMORY.md?
• What are agent skills?
• Hermes Agent
• What is OpenClaw?
• YC QM multi-agent harness

Sources

• github.com/TencentCloud/TencentDB-Agent-Memory — README, INSTALL, v2.0.0 release
• Project acknowledgements: CodeGraph, Hermes Agent, Karpathy LLM Wiki

Specs and PersonaMem figures reflect the public v2.0.0 README as of August 2026. Re-verify ports, migration tools, and benchmark methodology before production.