# TencentDB Agent Memory: a shared memory server for AI agent teams

> TencentDB Agent Memory puts a proxy in front of your agent's API and turns conversations, docs and code into four reusable assets. The install is a shell script and a .env file; the licence file is not a standard SPDX identifier, so read it before you deploy.

**TencentCloud/TencentDB-Agent-Memory** — GitHub describes it as TencentDB Agent Memory is a team-level memory hub for AI Agents , turning conversations, docs, and code into four reusable memory assets (Chat Memory, Skill, LLM-Wiki, Code-Graph) that are governed, shared, and equipped across agents and frameworks.. The repository metadata lists TypeScript as its primary language. The metadata lists the NOASSERTION license. This article stays within the project description and details documented in the GitHub repository README.

- Repository: https://github.com/TencentCloud/TencentDB-Agent-Memory
- Stars: 27,585 · Forks: 2,659
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-08-13 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/tencentcloud-tencentdb-agent-memory

## The problem: context that dies with the session

The README opens with a question rather than a feature list: how do you reduce repetitive work when using agents? The scenarios it names are concrete. Project context already explained in one session has to be explained again in the next. Documents already read get read again from page one by a different agent. A workflow that worked has to be rediscovered. None of that is a model quality problem, and no amount of prompt engineering fixes it, because the information has nowhere to live between sessions.

The project's answer is to widen the definition of memory. It states that memory here means more than remembering conversations, and that any information which helps the next agent avoid reinventing the wheel should be saved, organised and reused. That reframing matters, because it moves the scope from a chat transcript store to four asset types: Chat Memory, Skill, LLM-Wiki and CodeGraph. The intended audience is a team, not a solo user with one agent. The README describes a Memory Hub for agent teams where work produces assets, assets circulate, and a new member can load the team's save file on day one.

## Four asset types and the L0 to L3 distillation ladder

Chat Memory is the layer most people already expect. It retains preferences, facts, decisions and interaction history, and the README notes that each agent automatically gets its own memory when created. The storage model is a ladder: L0 Conversation to L1 Atom to L2 Scenario to L3 Persona, with raw conversations distilled layer by layer. The example the README gives is the kind of statement that is expensive to lose, a warning not to refactor an old auth module because mobile still depends on it. That is a decision with a long half-life and no natural home in a chat log.

Skill is the second asset and the one with the most structure. The README is explicit that a skill is not just a prompt snippet: it has versions, resource files, trigger boundaries, execution steps and validation rules. Personal skills are private by default and can be shared with the team after review. The third and fourth assets are knowledge-shaped. Wiki turns product docs, design specs and ops runbooks into structured pages with a link graph, and the README credits Karpathy's LLM knowledge base as inspiration. CodeGraph indexes code symbols, files, call relationships and impact paths, so an agent can search, read, inspect callers and callees, and run impact analysis before touching code.

The distinction between the last two is worth stating plainly: Wiki is for prose that describes intent, CodeGraph is for structure that constrains change. A team that only indexes one of them will still send agents back to the file tree.

## Installing TencentDB Agent Memory and pointing Claude Code at it

The supported path starts all three services at once: memory-core, memory-hub and proxy. The README gives a clone, a copy of .env.example, an edit step, and a single launcher script. It notes you must fill in two sets of LLM parameters, one for the memory group and one for the proxy group.

```bash
git clone https://github.com/Tencent/TencentDB-Agent-Memory.git
cd TencentDB-Agent-Memory/deploy/global-images
cp .env.example .env
$EDITOR .env       # Fill in two sets of LLM parameters (memory group + proxy group)
./start-all.sh     # Launch everything with one command
```

When the script finishes it prints a one-liner you can paste directly into Claude. The panel is then reachable at the URL below, which is the first thing to check before you touch any agent configuration.

```text
http://localhost:8125
```

Integration is deliberately boring. The README states that one proxy, an unchanged protocol and zero-code integration is the model: you point the agent's base URL at the proxy and it is done, with no plugin, hook or MCP server required. Per-client steps for Claude Code, Codex, CodeBuddy, WorkBuddy, Hermes, OpenClaw and DeepSeek Harness live in INSTALL.md, along with a generic guide for frameworks that are not listed. If you are upgrading from v1.x or v0.x, the repository ships a migration tool under MemoryCore/scripts/migrate-v2-to-v3 with its own README; the top-level README says new installations can skip it.

## Where the proxy approach breaks down

The proxy is the project's best design decision and its sharpest constraint at the same time. Because integration happens at the base URL, it works with any client that lets you change that URL. It also means every request now flows through an extra process that holds its own LLM credentials and its own failure modes. If the proxy is down, the agent does not degrade to stateless operation; it stops talking to its model. The README does not document a bypass mode or a fallback path, so plan for the proxy as a dependency with the same availability expectations as your model endpoint.

The second constraint is operational weight. This is not a library you import. It is three services, a panel, a .env with two credential groups, and a documented port reference in INSTALL.md. For one developer with one agent and short-lived sessions, that is a large amount of infrastructure to remember conversations that a longer context window might have covered anyway. The README's own framing points at teams, and the cold-start feature (importing existing documents, codebases and agent sessions) only pays off when there is existing material to import.

The third is governance. Skills are private by default and require review before sharing, which is the right default, but the README does not describe what a review workflow looks like in practice, who approves, or how a bad skill is revoked once it has been assigned to several agents. Treat that as an open question rather than a solved one.

## TencentDB Agent Memory compared with Mem0-style memory layers

Mem0 is the natural comparison, and it appears in the related searches for this project. The difference is scope, not quality. A Mem0-style memory layer is typically embedded in your application: you call it from your code, and it stores and retrieves memories for the agent you are building. TencentDB Agent Memory sits outside the application, in front of the model endpoint, and its unit of organisation is the team rather than the process.

That shows up in what each one stores. A typical memory layer stores facts and preferences extracted from conversations. TencentDB Agent Memory stores those as Chat Memory, but it also stores Skills with versions and validation rules, a Wiki with a link graph, and a CodeGraph with call relationships and impact paths. Those last three are not conversation artefacts, and extracting them requires reading documents and a codebase, which is why the install includes a hub and a panel rather than a single client library. The trade-off is direct: you get assets that survive a framework change because they are decoupled from the agent framework, and you accept a server, a proxy and a review process in exchange.

## Conclusion

Adopt it if you run several agents or several people against the same codebase and you are tired of re-explaining context, and if you are willing to run three services (memory-core, memory-hub, proxy) plus two sets of LLM credentials. Do not adopt it if you need a single-process library you can import into one agent, or if the NOASSERTION licence has not been cleared by whoever signs off on dependencies. Verify first that the v2 to v3 migration script applies to your data, that the ports in INSTALL.md do not collide with what you already run, and that your agent's base URL can actually be repointed at the proxy.

## FAQ

### What does agent memory mean in TencentDB Agent Memory?

The README defines it broadly: memory is more than remembering conversations, and any information that helps the next agent avoid reinventing the wheel should be saved, organised and reused. In practice that means four asset types: Chat Memory, Skill, LLM-Wiki and CodeGraph.

### Why do agents need memory?

The README frames the problem as repetitive work: project context already explained should not need repeating in a new session, documents already read should not be read again from page one, and a working workflow should not be rediscovered. Memory is the mechanism that stops that repetition.

### How to handle agent memory with TencentDB Agent Memory?

Run the three services from deploy/global-images with start-all.sh, fill in the two sets of LLM parameters in .env, then point your agent's base URL at the proxy. The README states no plugin, hook or MCP server is required.

### How to improve agent memory with TencentDB Agent Memory?

The README describes extracting Chat Memory and Skills from conversations and tasks, converting documents and code into Wiki and CodeGraph, and importing existing documents, codebases and agent sessions for cold starts. Assets are decoupled from agent frameworks so they can move between them.

## Sources

- [Official README](https://github.com/TencentCloud/TencentDB-Agent-Memory#readme)
- [Project repository](https://github.com/TencentCloud/TencentDB-Agent-Memory)
- [Release notes](https://github.com/TencentCloud/TencentDB-Agent-Memory/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tencentcloud-tencentdb-agent-memory