"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.
TencentDB Agent Memory is a team-level memory hub that turns conversations, documents, and code into four reusable memory assets:
L0 Conversation → L1 Atom → L2 Scenario → L3 Persona.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.
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) |
Post-deploy, four steps:
http://<host>:8125, log in with the sk-mem-... key from .admin-key.POST /v3/meta/user/create; save the returned default_user_key.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:
PROXY_FULL_STACK=1 (the default via start-all.sh).docker logs tdai-memory-hub — usually a mis-set REMOTE_INSTANCE_URL or LLM_BASE_URL.promptMode=chat and have real work conversations (edit files, run tests, draw conclusions) — small talk produces nothing worth persisting../stop-all.sh stops containers (keeps volumes); ./stop-all.sh --purge nukes everything.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...
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 |
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.
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.
Don't over-engineer your first pass. Do this:
.env, ./start-all.sh, create a Team + Agent, point your coding agent at the proxy.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.