Tencent Just Open-Sourced a Team Memory Hub for Agents — Here's How to Deploy It on Ubuntu and Build System-Level Skills in Go

"Open weights are table stakes now." That's how Tencent AI framed its latest gift to the agent ecosystem. While everyone argues about model size, Tencent quietly open-sourced the boring part — the infrastructure that makes agents actually useful over time: memory, skills, and sandboxing.

The headliner is Team Memory, aka TencentDB Agent Memory, which dropped its 2.0.0 beta on August 6, 2026, and promptly hit #1 on GitHub's TypeScript trending list. The pitch: same idea as Agent Memory, except now your teammates' agents can read it too.

For a developer running self-hosted agents on Ubuntu — the exact situation many of us are in with Go-based platforms — this is a goldmine. Let me walk through what Tencent shipped, how to get it running on an Ubuntu host in minutes, and how to build a system-level skill in Go that slots right into this architecture.

What exactly did Tencent ship?

TencentDB Agent Memory is a team-level memory hub that turns conversations, documents, and code into four reusable memory assets:

Chat Memory — preferences, facts, decisions, and interaction history, distilled down a pipeline: L0 Conversation → L1 Atom → L2 Scenario → L3 Persona.
Skill — reusable "how-tos" extracted from completed work. A Skill is not a prompt snippet; it has versions, resource files, trigger boundaries, execution steps, and validation rules.
LLM-Wiki — product docs, design specs, and ops runbooks as structured pages with a link graph.
CodeGraph — indexes code symbols, files, call relationships, and impact paths, so an agent knows "changing this might affect those."

The headline numbers (measured on OpenClaw over continuous long-horizon sessions) are hard to ignore: token usage down 61.38%, task success up 51.52% (relative), and PersonaMem accuracy up from 48% to 76%.

Crucially, memory here is not a flat vector pile — it's governed. Visibility is private (only the owner), team, restricted (via User/Role/Agent ACLs), or agent (targeted equipping). Sharing is an explicit action, not a default leak.

Deploying on an Ubuntu host (step-by-step)

The quick-start path is a four-service stack that boots with one command. Here's the full Ubuntu road:

Prereqs: an x86_64 Ubuntu host (20.04 / 22.04 / 24.04 all fine) with Docker + Docker Compose. No GPU required — the default upstream is a hosted model.

# 1) Clone and enter the deploy folder
git clone https://github.com/TencentCloud/TencentDB-Agent-Memory.git
cd TencentDB-Agent-Memory/deploy/global-images

# 2) Configure two sets of LLM credentials
cp .env.example .env
$EDITOR .env
#   MEMORY_LLM_BASE_URL / MEMORY_LLM_API_KEY / MEMORY_LLM_MODEL   ← for memory + hub
#   PROXY_UPSTREAM_URL / PROXY_UPSTREAM_API_KEY / PROXY_UPSTREAM_MODEL ← upstream LLM

# 3) (Optional) Validate config with a live LLM probe
./verify.sh

# 4) Boot everything
./start-all.sh

On first boot it creates an admin user, generates a random 32-char user_key, and saves it to deploy/global-images/.admin-key (reused across restarts). Four services come up on fixed ports:

Service	Port	Purpose
Memory Core	`8420`	memory read/write, auth, skill/RAG data plane
Panel UI	`8125`	team memory control panel
Knowledge	`8424`	wiki / code-graph service
Proxy	`8096`	LLM request proxy (Anthropic / OpenAI)

Ubuntu Docker deployment pipeline

Post-deploy, four steps:

Open http://<host>:8125, log in with the sk-mem-... key from .admin-key.
(Recommended) Admin creates a normal business user via POST /v3/meta/user/create; save the returned default_user_key.
In the panel, create a Team, then an Agent (with a description + system prompt like "bug-fix engineer" or "SQL tuner"). A Task is optional.
Point Claude Code at the proxy:

export ANTHROPIC_BASE_URL=http://127.0.0.1:8096/claude-code/default
export ANTHROPIC_AUTH_TOKEN="<the sk-mem-... user key>"
claude --model <PROXY_UPSTREAM_MODEL>

On its first turn, the proxy uses Claude Code's native AskUserQuestion tool to walk you through picking Team → Agent → Task. After that, every turn auto-injects that agent's L2/L3 memory, skills, and knowledge into the system prompt, while background workers distill new L1/L2/L3 from your conversation.

Common gotchas I'd flag for Ubuntu:

No picker appears? You need PROXY_FULL_STACK=1 (the default via start-all.sh).
Empty picker? The logged-in account must own at least one Team + Agent.
Panel says "8125 not started"? docker logs tdai-memory-hub — usually a mis-set REMOTE_INSTANCE_URL or LLM_BASE_URL.
L1/L2 never fires? Keep promptMode=chat and have real work conversations (edit files, run tests, draw conclusions) — small talk produces nothing worth persisting.
Tear down: ./stop-all.sh stops containers (keeps volumes); ./stop-all.sh --purge nukes everything.

Skills as first-class memory assets

Here's the part that got my attention as someone who thinks about agents as systems: a Skill is a full-fledged, versioned memory asset, not a prompt paste.

After complex work, the agent (or you) can extract a reusable Skill from a conversation and its tool calls, then share and assign it to specific teammates/agents. A Skill carries versions, resource files, trigger boundaries, execution steps, and validation rules. Personal skills are private by default; team sharing is a deliberate act.

The canonical format is exactly the SKILL.md standard — YAML frontmatter plus a workflow body. Tencent even ships a developer-agent skill this way inside CubeSandbox (.claude/skills/run-dev/SKILL.md). It looks like this:

---
name: release-checklist
description: Run a release validation checklist before shipping. Trigger when a release is tagged.
version: 1.0.0
---
## Workflow
1. Run the test suite...
2. Check migrations...
3. Tag and summarize...

Building a system-level skill in Go (agent.go)

Now the fun part that bridges to Go-based agent platforms (like a self-hosted nxsandbox-style runtime). A prompt-based skill is a markdown file the LLM reads. A system-level skill in agent.go is a privileged, compiled capability — registered at startup, not user-defined at runtime. It gets to call platform APIs (files, memory, DB, sandbox) directly and is trusted by default.

Here's the pattern I'd use — parallel to Tencent's "versions + triggers + validation" model:

// skill.go : a system-level skill core
type Skill struct {
    Name          string   // e.g. "release-checklist"
    Description   string   // what it does + when to trigger
    IntentKeywords []string // auto-trigger keywords
    Handler       func(ctx *AgentCtx, args JSON) (*SkillResult, error)
}

// agent.go : register system skills at init
func (a *Agent) registerSystemSkills() {
    a.skills.Register(go.Skill{
        Name: "release-checklist",
        Description: "Run release validation before shipping",
        IntentKeywords: []string{"release", "ship", "tag", "checklist"},
        Handler: a.handleReleaseChecklist,
    })
    a.skills.Register(go.Skill{
        Name: "code-impact",
        Description: "Run impact analysis before changing code",
        IntentKeywords: []string{"impact", "callers", "refactor"},
        Handler: a.handleCodeImpact,
    })
}

The handler is a privileged function that can reach into the platform:

func (a *Agent) handleReleaseChecklist(ctx *AgentCtx, args JSON) (*SkillResult, error) {
    tests := ctx.RunTests()             // platform API
    migs  := ctx.RunMigrations()        // platform API
    ctx.Memory.Store("release:"+args.Tag, map[string]any{ // shared team memory
        "tests": tests.Pass, "migrations": migs.OK,
    })
    return &SkillResult{Summary: fmt.Sprintf("tests=%v migs=%v", tests.Pass, migs.OK)}, nil
}

Key differences vs. a prompt skill:

Prompt skill (SKILL.md)	System-level skill (agent.go)
Markdown, LLM interprets	Compiled Go, runs natively
Read-only instruction	Privileged handler with platform access
Triggered by coincidence	Triggered deterministically via registry + intent match
No side effects by itself	Can write memory, run tests, hit DB

Go agent skill registry architecture

The elegant part: you can have both. Keep the markdown SKILL.md so the LLM understands when to use it, and back it with a compiled Go handler so the actual execution is fast, reliable, and sandboxed. That's exactly the layering philosophy Tencent preaches — symbolic, deterministic top-layer with a traceable bottom-layer.

Memory + sandboxing: the whole open-Tencent stack

Agent Memory isn't the only thing Tencent open-sourced. CubeSandbox (Apache 2.0) delivers per-conversation, hardware-isolated sandboxes with browser, code, shell, and file access — spun up in under 60ms with <5MB overhead, E2B-compatible. The two together form a coherent thesis: open weights are table stakes; the moat is memory and sandboxing.

For anyone building on Go, that thesis is directly transferable: your agent runtime should own both shared, governed memory (skills + context that compound across sessions) and ephemeral, isolated execution (spin up a sandbox, do the work, tear it down). Those are the two pieces that turn a demo agent into a persistent digital teammate.

Start small, compound fast

Don't over-engineer your first pass. Do this:

Stand up the memory stack on Ubuntu — clone, .env, ./start-all.sh, create a Team + Agent, point your coding agent at the proxy.
Watch one Skill get auto-extracted from a real work session, then share it team-wide.
Prototype ONE system-level skill in agent.go that touches your platform's strongest capability (running tests, a DB query, an internal API), registered with intent keywords.

That single skill becomes the seed of a library. Every time an agent does the thing once, it never has to learn it again — and neither does anyone else on the team.

Tencent's tagline nails it: "Agents remember. Humans innovate." The agents remember because you gave them somewhere to put the memories. Build the shelf in Go, deploy it on Ubuntu, and start compounding.