TencentDB Agent Memory v2.0: Shared, Governed Memory for AI Coding Teams

Tencent Cloud released TencentDB Agent Memory v2.0 on August 3, 2026, and put it on GitHub under an MIT license. The project gives AI coding agents a shared, governed memory store so that context explained in one session, by one agent, does not have to be repeated in the next. The core addition over earlier single-agent memory tools is a permission layer that lets a teammate's agent read what your agent learned, while keeping anything you marked private completely off-limits, even to team admins.

What happened

Detail	Fact
Release date	August 3, 2026
License	MIT
Deploy method	Three Docker images, one command
Architectures	linux/amd64 and linux/arm64
Default ports	8420 (Memory Core), 8125 (panel), 8424 (knowledge service), 8096 (proxy)
SDKs	TypeScript and Python
PersonaMem accuracy	48% baseline, 76% with the system (self-reported)

The system converts agent work into four named asset types. Chat Memory holds preferences, decisions, and interaction history. Skill distills reusable procedures from completed tasks, with versions, resource files, and validation rules attached. Wiki turns documents into structured pages with a link graph, drawing on Andrej Karpathy’s idea of an LLM-maintained knowledge base. CodeGraph indexes symbols, files, call relationships, and impact paths across a codebase. All four register with the same ownership, version, status, and visibility fields.

How the memory pipeline actually works

Chat Memory is not a flat log. Conversations are saved as L0, then an asynchronous pipeline refines them into L1 Atom, L2 Scenario, and L3 Core/Persona. On each new turn, L2 and L3 provide a fast context bootstrap. When specific facts are needed, the system falls back to L1 and L0 using a combined BM25 plus vector retrieval plus RRF (Reciprocal Rank Fusion) approach. Results are capped by item count, character budget, and timeout to avoid crowding out the model’s context window.

The proxy layer speaks both Anthropic and OpenAI protocols, exposing endpoints at /claude-code/<spaceId>/v1/messages and /v1/chat/completions. On the first turn, a session-init step uses Claude Code’s native AskUserQuestion tool to select team, agent, and task. Every following turn injects that agent’s L2/L3 memory, matched skills, and knowledge pages into the system prompt before the request goes upstream. Supported integrations include OpenClaw, Hermes, Claude Code, and CodeBuddy.

Why does governance matter more than raw retrieval?

Standard RAG (retrieval-augmented generation, where a model looks up relevant text before answering) tells you what can be found. TencentDB Agent Memory v2.0 also enforces who may use it, which version is active, and which specific agent receives it. Visibility has three levels: private (owner-only, not readable even by team admins), team, and restricted. New Chat Memory and Skills default to private, so sharing is always a deliberate choice, not the default.

The retrieval step narrows by team, user, agent, and visibility before it even starts looking for content. That binding-first approach is what separates this from a shared vector database with basic access tokens. It is also where the product is still maturing: private-repo CodeGraph indexing and automated memory routing are listed as unfinished in the README. For context on where this fits in the broader push toward persistent AI agent infrastructure, see our coverage of the adoption gap between AI agents and general chatbots.

Who should use it right now

According to the project documentation, the clearest wins fall into three groups:

• Solo builders and small engineering teams: the project explicitly targets one-person companies. Setup is one command and there is no vendor API dependency.
• Mid-size teams with a platform or developer experience function: can run it as shared internal infrastructure across multiple agents and projects.
• Large regulated enterprises: should pilot rather than standardize. Private-repo CodeGraph and automated memory routing are still being refined.

Practical use cases named in the documentation: onboarding a new agent to an existing codebase, impact analysis before refactoring, release checklists, incident runbooks, code review standards, and converting product docs into agent-readable pages. Industries called out include software and developer tooling, SaaS, fintech, consulting, and agencies.

Our take

The governance layer is the genuinely interesting part here. Most teams experimenting with AI coding agents today are running them session-by-session, re-explaining the same architectural decisions every time. A shared, permissioned memory store that defaults to private solves a real coordination problem, especially for agencies or consultancies where multiple agents touch multiple client codebases.

That said, the 48%-to-76% PersonaMem improvement is self-reported and has not been reproduced independently. Treat it as directional. The unfinished private-repo CodeGraph is also worth watching: that is the feature most regulated teams will need before they can move past a pilot. If you are already working on AI integration for your team’s workflows, this is worth deploying in a sandboxed project now to understand the setup overhead before the product stabilizes further.

The MIT license and self-hosted Docker deployment remove the usual vendor-lock objections. For agencies handling client work, that matters. One command, no external API dependency, and you own the data.

What to do about it

1. Pull the three Docker images from Docker Hub and run the one-command install against a non-production project.
2. Map your current agent sessions to the four asset types: decide what becomes Chat Memory, what becomes a Skill, and what belongs in CodeGraph.
3. Set visibility defaults deliberately. New memories default to private; decide as a team which asset types should default to team-visible.
4. Hold off on standardizing CodeGraph for private repos until the repository-sync feature stabilizes, per the project’s own documentation.
5. Check the CHANGELOG after each release. The 2.0.0 release already added Cost Guard (cheaper models assigned to specific agents), and the roadmap is moving fast.

If your team is already running multiple AI agents across client projects, this is the most practical open-source option available today for shared memory governance.

Source: Marktechpost