On the same day v2 was finalized, we finished the full 10-session validation run and stacked vector reranking on top: NylonME's official LoCoMo recall@10 moved from 60.2% to 84.6%. This article has been rewritten with the latest data and the complete experiment chain.
Opening: Why Compare These Two?
In China's AI Agent memory track, three forces are most worth watching right now:
- MemOS (memory tensors): advised by CAS academicians, nearly ¥100M in angel funding, a Neo4j + Qdrant heavy-stack system, academia-first.
- TencentDB-Agent-Memory (Tencent Cloud): built by a big-tech team, an L0–L3 four-tier progressive architecture + zero-dependency local deployment on SQLite, 9,300+ GitHub stars — the signature work of engineering pragmatism.
- NylonME (Nylon Memory Engine): what we're building — Rust-native, six-silk memory model, contextual resonance retrieval — an engine that treats memory as the core of the architecture, not a bolt-on for the LLM.
We've already compared the first two in an internal report. This article goes straight to the point: what is the essential difference between NylonME and TencentDB-Agent-Memory? This time, we bring experimental data.
1. Architectural Philosophy: What Sits at the Center?
This is the most fundamental divergence.
The TencentDB-Agent-Memory architecture is:
LLM reasoning → context offload → tiered memory storage (L0–L3) → inject before next reasoning
Memory works on the periphery of the LLM. Its core value is "saving tokens for the LLM" — compressing conversation history into L1 Atom facts, L2 Scenario blocks, and L3 Persona profiles, so that only the relevant compressed versions get injected on the next LLM call. A 61%+ token saving (vendor's own measurement) — that capability is real.
The NylonME architecture is:
Input → memory engine (contextual resonance) → LLM reasoning → results written back to memory
Memory sits in front of the LLM. The LLM is an inference peripheral of the memory engine — not the other way around.
One example makes the difference clear:
- The Tencent approach: the user asks "what was the outcome of my broadband outage last time?" → the LLM receives the prompt → the LLM calls a memory-retrieval tool → gets back a few L1 Atoms → the LLM summarizes an answer.
- The NylonME approach: user input arrives → the memory engine identifies the user ID → resonates out the complete context network along the relation graph (work order + modem model + technician visit time + emotional intensity + related preferences) → hands the contextual bundle to the LLM → the LLM reasons → the conclusions are written back to memory.
In one sentence: in the Tencent architecture, memory is a tool invoked by the LLM; in the NylonME architecture, memory is the context engine that drives reasoning.
2. The Key Experiment: Can the Abstract Layer Replace Raw Memories?
Tencent's L0→L3 model carries an implicit assumption: information can be compressed tier by tier, and the compressed high-tier representations can replace low-tier details in reasoning. The L0 raw conversation is kept mainly for retrospective drill-down; what actually feeds the LLM is the compressed Atom / Scenario / Persona. This is the natural corollary of the "save tokens" goal, and it is the mainstream practice in tiered memory design today.
We were preparing to do exactly the same. On 2026-08-11, we integrated DeepSeek for LLM weaving and ran a set of ablation experiments on the LoCoMo long-conversation memory benchmark (bge-m3 embeddings, one-session controlled comparison on the same QA set):
| Experiment | Write strategy | recall@10 |
|---|---|---|
| E1 | Heuristic baseline (single-layer raw memories) | 70.7% |
| E2 | LLM per-turn decomposition, replacing heuristics | 70.7% (net zero) |
| E3 | LLM session-level abstraction, abstract layer only | 67.3% |
| E4 | Dual-layer coexistence: leaf layer = verbatim turns + abstract layer = session facts | 78.7% |
E3 is the most informative. The abstract layer did lift multi-hop reasoning questions (Cat1/Cat3) noticeably — but detail-precision questions (Cat2/Cat4) fell in lockstep, and the overall score dropped 3.4 points. The reason is not complicated: compression is lossy, and somewhere in the discarded details there is always a piece that happens to be the answer to some question. When the user asks "which floor was that restaurant we talked about on?", a session-level summary most likely retains only "the user discussed a restaurant."
E4 gives the correct solution: the abstract layer does not replace the leaf layer; both coexist and both participate in retrieval. The leaf layer preserves detail precision, the abstract layer supports cross-turn reasoning, and all four QA categories beat the baseline.
We then pushed this configuration to the full benchmark and added one final ranking optimization — vector reranking (candidates activated by resonance get a second cosine-hybrid scoring pass against the query vector). The complete experiment chain (LoCoMo recall@10):
| Stage | Configuration | Result |
|---|---|---|
| Starting point | Lexical retrieval baseline | 47.1% (full 10 sessions) |
| Semantic | bge-m3 embeddings + lexical/vector dual-seed channels | 60.2% (full 10 sessions) |
| Retrieval tuning | Seed fusion + weighted scoring | 70.6% (2-session basis) |
| Dual-layer write | Leaf layer + abstract layer coexistence | 78.7% (1-session ablation) |
| Adaptive depth | 0 hops for detail questions / 4 hops for reasoning questions | 80.1% (2-session basis) |
| Same config, full run | — | 84.2% (full 10 sessions) |
| Vector rerank | Query-vector cosine hybrid scoring (weight 0.5) | 84.6% (full 10 sessions — current official figure) |
From 47.1% to 84.6% — every one of the 37.5 points gained has a controlled experiment behind it. The last vector-rerank step looks worth only 0.4 points, but its structure is beautiful: multi-hop reasoning questions (Cat1) rose from 80.5% to 83.0% — graph diffusion recalls more candidates, and vector reranking moves the most on-point ones to the front.
This set of experiments also rules out two wrong hypotheses, worth recording:
- A tension floor does nothing. We had assumed old memories would need a tension floor to guard against decay over-penalizing them — measurements showed the benchmark's nodes are all freshly written, with tension ≈ 1 to begin with. The premise didn't hold.
- Guaranteed seed quotas are a no-op. We had assumed vector seeds would need reserved quota slots — measurements showed the 28 seeds nearly fill the diffusion budget of 32, leaving almost no room for diffusion nodes to claim a quota anyway.
And one honest admission about the ceiling: detail-distraction questions (Cat4) remain about 5 points from the theoretical upper bound. Our judgment is that this is the limit of bge-m3 — distractor conversations and the evidence share entities, so they can't be separated at the embedding level. Moving this will take a cross-encoder reranker (e.g., bge-reranker-v2-m3).
Measurement note: 84.6% is recall@10 on the full LoCoMo benchmark of 10 sessions and 1,536 answerable questions; the HNSW index carries ±1.5 points of noise. All evaluation scripts and switches are open-sourced and reproducible. Tencent has not published LoCoMo results, so a direct side-by-side comparison isn't possible.
The lesson for tiered memory design: it's not the tiers that are wrong — it's "tier replacement" that's wrong. Raw text must not live only in a retrospective corner; it must stay on the retrieval path. Compressed artifacts are an increment, not a replacement.
To be fair, Tencent keeps the L0 raw text for drill-down — more prudent than pure replacement. But at the critical step of "what gets fed to the LLM," its retrieval path still centers on the compressed tiers — precisely the pit we fell into with E3.
3. Memory Representation: Tiered Tree vs Graph Network
Tencent's four-tier model (L0 Conversation → L1 Atom → L2 Scenario → L3 Persona) is currently the most meticulous tiered design in the industry, and its strengths are obvious:
- Each tier is independently replaceable (swapping L2 doesn't affect L3)
- Data is traceable (an L3 profile can be drilled all the way back to the L0 raw conversation)
- White-box and readable (Markdown / JSONL, human-friendly)
But a structural cost remains: the tiers are vertical; there are no horizontal associations. "The user prefers window seats" and "the user went to Tokyo last month" are two isolated Atoms — the connection between them can only be inferred by the LLM at retrieval time, not built at write time.
NylonME's six-silk graph model takes a different path. Every memory is woven from six silks (fact, relation, temporal, emotion, frequency, provenance), and memories are explicitly linked to each other through relation silks — not a tiered tree, but a directed, weighted graph:
[Broadband outage work order #1024]
|-- relation silk --> [Modem model: Huawei HG8245]
|-- relation silk --> [Customer emotion: anxious, 0.8]
|-- relation silk --> [Preference: latency-sensitive]
|-- temporal decay --> tension naturally drops after 30 days
|-- frequency silk --> mentioned 3 times, +0.3 forgetting resistance
This week's architecture upgrade added a second level to this graph: dual-layer writes. Leaf-layer nodes store verbatim turns; abstract-layer nodes store LLM-distilled session-level facts. Both coexist in the same graph and both participate in recall — this is exactly the productization of the Section 2 experiment conclusion. The engine has a built-in WeaveSession RPC: when a session ends, it automatically completes the full flow of "write each turn to the leaf layer → LLM abstraction into the abstract layer → conflict detection."
In one sentence: the Tencent approach uses the LLM's reasoning to compensate for the storage layer's missing relations; the NylonME approach builds relations into the storage layer and lets raw text and abstractions coexist there. The LLM receives an already-organized, dual-granularity context network.
4. Where the LLM Sits: Compression Pipeline vs In-Engine Understanding
Both systems use LLMs to process memory, but the LLM stands in a completely different place.
Tencent's LLM is inside a compression pipeline: it symbolically compresses conversations into Atom / Scenario / Persona (including compressing process descriptions into Mermaid syntax), with the goal of reducing token consumption.
NylonME's LLM does three things inside the engine:
- Weaving decomposition: at write time, it extracts structured six-silk elements from raw events (fact, relations, emotional valence and intensity, confidence), replacing the early heuristic rules.
- Conflict detection: when a new memory is written, the engine first uses HNSW under a lock to find the top-4 candidates with the same subject, then lets the LLM judge — outside the lock — whether they contradict; contradicting nodes are returned with the response — "the user said last week they don't eat spicy food, this week they can't live without it" won't be silently overwritten.
- Session-level abstraction: the abstract layer of dual-layer writes, distilled by the LLM when a session ends.
The key design constraint: the LLM is an enhancement, not a dependency. When the LLM endpoint is unavailable, the engine automatically falls back to heuristic decomposition and rule-based detection; the core read/write path is unaffected. We don't believe a memory engine should go down because an LLM went down.
5. Retrieval: Hybrid Recall vs Contextual Resonance
| Dimension | TencentDB-Agent-Memory | NylonME |
|---|---|---|
| Retrieval entry | Keyword / vector / hybrid (RRF fusion) | Lexical + vector dual-seed channels |
| Recall strategy | BM25 + embedding → Top-K | Seed nodes → graph diffusion → tension ranking |
| Diffusion depth | No graph structure, N/A | Adaptive by question type (0–4 hops) |
| Candidate reranking | None | Query-vector cosine rerank (optional, weight tunable) |
| Association | Inferred by the LLM after retrieval | Pre-built into the graph at write time |
| Forgetting | None (or manual deletion) | Exponential decay T(t) = T0·e^(−λt) |
| Emotional weighting | None | Emotion-silk intensity weighting |
| Frequency promotion | None | High-frequency memories gain forgetting resistance |
Tencent's BM25 + vector + RRF is the industry-standard approach — mature and reliable. But two old questions remain unanswered:
- How do you recall memories "associated with the current context but whose keys don't match"? The user asks "my internet has been lagging lately" — if no L1 Atom contains the keywords "internet" or "lag", and vector similarity misses too, that valuable outage memory sinks without a trace. NylonME's graph diffusion can: the earlier work order is linked via relation silks to a "latency-sensitive" tag; "laggy internet" lexically hits "latency", activates the tag, and diffuses along the graph to the work order.
- How do you rank "which of the ten relevant memories matters most"? Tencent relies on the fused BM25 + cosine similarity score. NylonME ranks in three stages: tension scoring (encoding temporal decay, emotional intensity, frequency bonus) → adaptive diffusion by question type → query-vector cosine rerank. That last stage was added this week, specifically to fix "graph diffusion recalls plenty but the most on-point result isn't ranked first" — a measured +2.5 points on Cat1 multi-hop reasoning questions.
Adaptive associative depth comes from a hard-learned lesson: running multi-hop diffusion on every question hurts detail-precision questions (diffusion introduces noise). Detail questions now get depth 0 (only direct seed associations), reasoning questions up to 4 hops. Retrieval strategy should vary with question type — something we haven't yet seen in any comparable open-source project.
6. Tech Stack and Deployment: Python vs Rust
| Dimension | TencentDB-Agent-Memory | NylonME |
|---|---|---|
| Core language | Python | Rust |
| Local storage | SQLite + sqlite-vec (zero-dependency default) | Embedded CSR + HNSW + WAL (in-process) |
| Vector index | sqlite-vec / Tencent Cloud VectorDB | Self-built HNSW |
| Graph storage | None (pure tiered index) | Self-built CSR compressed graph |
| Deployment | pip install (lightweight) | Single binary (even lighter) |
| Write TPS | Not disclosed | 12,494 (WAL group commit, measured at 32-way concurrency) |
| Memory (1M nodes + 10M edges) | N/A (no graph structure) | 720 MB real text / 432 MB minimal basis |
| Cloud service | Tencent Cloud VectorDB (optional) | On the roadmap |
Tencent's zero-dependency design is very clever — one pip install and it runs; SQLite is bundled, no database to install. This is a big reason its GitHub stars shot past 9,300.
NylonME went to the other extreme: a Rust kernel, CSR graph structure + HNSW vector index all embedded in-process, compiled into a single binary — even lighter than pip install. The trade-off is development speed and ecosystem richness far below Python's.
There's no absolute "better" here — only what fits your stack: Python full-stack teams integrating quickly should pick the Tencent option; teams with hard requirements on memory, latency, and throughput who are willing to tangle with Rust will find NylonME the better substrate.
7. Current State and Differences at a Glance
| Dimension | TencentDB-Agent-Memory | NylonME |
|---|---|---|
| License | MIT | Apache-2.0 |
| Core language | Python | Rust |
| Memory model | L0–L3 four-tier progressive | Six-silk graph network + dual-layer writes + tension decay |
| Relation storage | None (tiered index) | CSR directed weighted graph |
| LLM's role | Compression pipeline (save tokens) | Weaving decomposition + conflict detection + session abstraction (with fallback) |
| Retrieval | BM25 + Vector + RRF | Contextual resonance (dual seeds + graph diffusion + tension ranking + vector rerank) |
| Associative depth | N/A | Adaptive 0–4 hops by question type |
| Forgetting | Manual | Adaptive exponential decay |
| Emotion modeling | None | Emotion silks + intensity weighting |
| Team memory | Yes (Team Memory) | On the roadmap |
| Deployment | pip install (zero-dependency SQLite) | Single binary (zero-dependency) |
| Write TPS | Not disclosed | 12,494 |
| LoCoMo recall@10 | Not disclosed | 84.6% (full 10 sessions: dual-layer writes + adaptive depth + vector rerank) |
| GitHub stars | ~9,300+ (Aug 2026 snapshot) | New project |
| Cloud service | Tencent Cloud VectorDB (optional) | On the roadmap |
Final Words
Putting the two side by side is not about declaring a winner. Frankly, the Tencent team is still far more mature in engineering execution than we are — the four-tier model, symbolic compression, white-box traceability, Team Memory: every one of these is a battle-tested design. The 9,300 stars didn't come from nowhere.
But this week's experiments turned the closing line of our first version into data. Back then we said: "there are always things compression loses, and what gets lost happens to be critical information in some context." At the time, that was intuition. Now it's an experiment: keep only the abstract layer, and recall drops 3.4 points; let both layers coexist, and all four QA categories rise; add adaptive depth and vector reranking, and the full benchmark reaches 84.6%.
Memory should not be a mere accessory to the LLM. A compression pipeline lets the LLM read summaries ever more cheaply, but what an agent truly needs is a memory system that associates, forgets, detects contradictions, and moves freely between raw text and abstraction.
The two paths will ultimately lead to two different product shapes. Which one is right — time and the market will tell.
NylonME is open-sourced at github.com/nylon-memory/NylonME, Apache-2.0, evaluation scripts included in the repo. Criticism is welcome — and reproductions even more so.
This is Part 4 (v3, 2026-08-12) of the NylonME technical blog series. TencentDB-Agent-Memory data in this article comes from its public GitHub repository and official articles (Aug 2026 snapshot); performance figures are vendor self-tests, not independently reproduced. All NylonME experiment configurations and measurement bases are itemized in the article.
Top comments (0)