In a field where memory systems can't reliably beat
cat *.txt on accuracy, Sibyl's edge isn't a bigger number —
it's making auth-scoped, graph-native team memory a
database guarantee instead of an application-layer hope: the one layer the
frontier labs won't build and the benchmarks say no one has solved.
The AI-memory field in mid-2026 has a credibility problem. Purpose-built memory systems routinely fail to beat a plain full-context baseline on accuracy: on LoCoMo a no-memory baseline scores ~73% — matching or beating "sophisticated" systems — and every headline leaderboard number is self-reported on a different harness. When the two most-cited systems (Mem0 and Zep) audited each other, both scores moved by 15–25 points. The honest, defensible wins here are cost, latency, token-efficiency, and isolation integrity — not a leaderboard.
Two structural facts make Sibyl's position stronger than it looks.
A unified engine matters: Mem0 dropped external graph stores, Cognee's isolation works on only three backends, Papr stitches four databases together. But SurrealDB's own Spectron ($23M, Feb 2026) now makes the unified-substrate, typed-memory, forgetting-as-a-verb argument on the very engine Sibyl runs on. You can't out-database the database vendor — so Sibyl competes above the substrate: the governed, self-hostable memory product.
Almost all "multi-agent memory" is just per-agent namespacing. The 2026 governance literature names four failure modes no system clears (leakage, stale propagation, contradiction persistence, provenance collapse); GateMem shows no method achieves utility, access control, and forgetting together; and no public benchmark measures team memory at all. Sibyl already ships the two hardest prerequisites: a real auth runtime and a unified graph.
The bet is a three-release arc: Prove It — close the table-stakes eval gaps honestly, at PR-gating cadence, and lay the team-memory substrate. Coalesce It — safely — ship live, provably-scoped, reversible team-memory coalescence, and build the team benchmark internally. Lead It — publish the benchmark the field lacks and push the frontier.
Every claim below is grounded in verified code reality and a pinned run, not the frozen pre-1.0 planning docs. The honest gaps are listed as plainly as the wins.
apply_temporal=True, 365-day half-life); the
context/recall path does not (temporal_target=None).
priority_decay archives low-importance entities reversibly — but it reads
usage fields (last_recalled_at / last_used_at) that
nothing writes (verified 2026-07-03), so forgetting is effectively age-only:
"old = dead" instead of "unused = dead." No citation contract, no recall stamping, no
usage signal anywhere in the loop.
v0.12) mean extraction
improvements could replay over the whole historical corpus — but no re-extraction path
exists. Tasks and memories share one graph, so memory utility could be grounded in
task outcomes — but no outcome signal is derived. Both properties are unique in the
field; neither compounds yet.
MemoryScope.TEAM is hard-disabled in three places. The
teams / team_members tables and RBAC resolution exist but
there's no team-management route or CLI. Two coalescence engines exist — online
retrieval/dedup.py (HNSW + cosine) and offline
migrate/merge.py — and the sibyl-consolidation/ merge
tarballs are a real dogfood of exactly this.
large_corpus_rehearsal is 57 records; zero competitor baselines run.
Most rivals bolt memory onto the application layer; the substrate vendors now sell memory too. Sibyl's durable edge isn't the storage engine — it's the governed, self-hostable memory product and the coalesced-team-memory frontier no one has cleared.
| System | Substrate | Isolation | Coalesced team memory | Principled forgetting | Open / self-host |
|---|---|---|---|---|---|
| Sibyl | unified graph + doc + vector + FTS + auth, one engine | physical namespace-per-org | building substrate ready; coalescence is the v1.2 bet | partial decay + reversible archival; unifying in v1.1 | OSS product MCP + CLI + web, self-hostable |
| SurrealDB Spectron | unified same engine class as Sibyl | scope grants DB-enforced, claimed | claimed newest, least-demonstrated | forget-verb first-class, claimed | preview invite-only · commercial TBD |
| Neo4j agent-memory | graph+vector no document / time-series model | app-layer | shared brain mature, with provenance | noneprovenance, no decay | GPLv3 + Aura |
| Zep / Graphiti | temporal KG over Neo4j / Falkor | app-layer | group graphs shared, coarse | bi-temporal edge invalidation — best-in-class | Graphiti OSS Zep CE deprecated |
| Mem0 | split (BYO) vector + optional graph | app-layer | namespacing | minimalsearch-time re-rank | Apache-2.0 layer bring your own backends |
| Letta / MemGPT | runtime Postgres + pgvector | app-layer | shared blocks real coalescence | sleep-time background consolidation | Apache-2.0 |
| Cognee | stitched relational + vector + graph | partial 3 of N backends | no | aspirational | Apache-2.0 |
Every headline benchmark number in this space is self-reported on a non-standardized harness. Marks: green = truthful strength · yellow = partial / claimed / app-layer · grey = absent or unproven.
The sharpest competitor is our own substrate vendor. SurrealDB's Spectron makes nearly Sibyl's entire differentiator list — on the engine Sibyl depends on. The lesson isn't to out-database the database; it's that the substrate was never the moat. Sibyl's moat is the governed, self-hostable memory product above it — the memory loop as legible verbs, a real auth runtime, task coordination as a first-class memory citizen, and coalesced team memory the benchmarks say no one has solved. Spectron is a preview engine; Sibyl is a complete, installable product on the frontier the labs refuse to build.
Every headline in this field is self-reported on a different harness. When the two most-cited systems audited each other, both scores moved 15–25 points. Our moat isn't a leaderboard slot — it's a measurement discipline.
A no-memory control (subtract parametric knowledge, report the memory lift); the judge model and exact prompt disclosed; N ≥ 5 runs with confidence intervals; parallel — not sequential — retrieval for latency; and competitor configs published so they can object. One canonical run, never rounded up.
Single-agent memory has quietly converged on a mature stack: bi-temporal graphs, hybrid retrieval, tiered consolidation. The moment the field turns to shared memory, it falls apart. That is the opening.
We don't compete where it's solved. We lead where it's open.
The 2026 governance literature has already named the way shared memory breaks. Any system that lets multiple agents or people write into one memory faces the same four failure modes — and current systems trip every one of them.
Data crosses a tenant or sub-tenant boundary it was never scoped to.
Outdated facts keep circulating long after they stopped being true.
Conflicting facts coexist unresolved, and the system can't say which holds.
Who asserted what, and from where, becomes unrecoverable.
"No method simultaneously achieves strong utility, robust access control, and reliable forgetting." — GateMem (arXiv:2606.18829), benchmarking memory governance across multi-principal agents · 2026
The field's own prescribed cure is four systems primitives — scoped retrieval, temporal supersession, provenance tracking, and policy-governed propagation — and its own benchmarks show nobody has assembled them into something that holds. Sibyl already ships the two hardest prerequisites the academic prototypes bolt on after the fact: a real multi-tenant auth runtime (namespace-per-org) and a unified graph. The primitives aren't a research project for us; they're the substrate we already stand on.
A bi-temporal, provenance-carrying, scope-governed unified graph — where compatible knowledge merges by convergence, conflicting knowledge supersedes by valid-time invalidation (never destructive overwrite), forgetting is outcome-conditioned, and a background dream cycle consolidates while keeping every summary linked to its lossless evidence.
No published system does all of this together. Governed coalescence over a bi-temporal graph — with forgetting tied to whether a memory actually helped, which only a task-aware system can measure — is the position Sibyl is uniquely shaped to own. The three-release arc below is how we earn the right to claim it.
No public benchmark scores whether memories written by many agents coalesce into one correct, attributable, isolated graph. CoalesceBench is that benchmark — pluggable through a standard Insert/Query API so every existing memory system can be run against it, and co-evolving with Sibyl's own namespace-per-org isolation and provenance edges.
A fact written by agent A must answer agent B's later query; the hidden-profile variant needs facts uniquely held by ≥2 agents. Does the graph merge, or silo per writer?
Contradictory writes — temporal and authority-based. Return the superseded-correct answer, or surface both with provenance when it's genuinely unresolvable.
"Who established fact F, and through what derivation chain?" — including multi-hop derivations. Essentially untested in public today.
Two tenants with deliberately similar facts under concurrent writes; scoped queries must never leak, even under adversarial paraphrase and embedding collision.
Overlapping multi-agent experiences dedupe and merge without double-counting; deletions propagate to every reader (no stale propagation).
Report the five axes as a vector; always include a no-memory and a single-agent control so "team lift" is explicit. Any nonzero cross-tenant leakage caps the composite — isolation is a safety property.
One private-memory leak or one irreversible bad merge makes team memory radioactive. Every coalescence action must be scoped-by-construction, attributable, previewable, and undoable. This principle governs the entire sequencing of the arc.
Not benchmark size — the field's only honest edge and Sibyl's structural strength.
One canonical run, never round up, and the retrieval-vs-QA-accuracy caveat always travels with the number.
Memory systems accumulate hallucinations during extraction/update that QA-only judging hides (HaluMem).
Every gate names numeric thresholds: recall, latency, leak, error, cost.
LoCoMo is saturated, has ~6.4% wrong gold answers, and is harness-dependent. Prioritize LongMemEval-V2 and Sibyl's own team benchmark.
Be the MCP-native, OKF-speaking backend behind others' memory tools rather than competing with client-side file memory. Structured substrate, curated projection: the graph is the source of truth; filesystem-native agents get it as curated files.
Linear work improves the system additively; feedback loops compound. Sequence loop-closing (usage signal, re-extraction, outcome grounding) ahead of parameter tuning — never tune a decay function whose input signal does not exist yet.
Make every public claim boring and complete. Move evals from manual to PR-gating, finish the eval story, close the usage feedback loop, and enable the team-memory substrate. No headline claim ships without a receipt.
Add a reader pass over Sibyl's retrieved LongMemEval-S sessions plus the official judge; publish QA accuracy alongside the 96.96% R@5 retrieval number. Closes the miscategorization gap where tables read retrieval recall as QA accuracy.
Scheduled real-key runs (stratified nightly, full weekly); a committed time-series ledger; and a deterministic local-embedding variant so quality gates run on PRs without OpenAI cost or nondeterminism.
Co-report tokens per query, embedding calls, p50/p95, and a dollar estimate against a full-context baseline, in every live artifact.
Measure whether extraction and consolidation inject or reduce hallucinations, and gate it. On-trend, under-shipped by competitors, consistent with the honest posture. Plus two cheap hygiene guards: a self-feeding guard (the dream cycle must never digest its own reflection output) and a no-op gate on background extraction (minimum signal or write nothing).
Stand up the official-full harness and publish the LAFS-Gain number with a citable receipt. The external leaderboard is empty and the benchmark is agent-shaped — it matches Sibyl's coding/agent use case, so an early credible entry is high-leverage.
Write the usage fields the decay machinery was designed to read. Context packs
already carry stable item IDs; the skill packs ship a citation contract (a
cited_ids field on task complete / reflect,
or sibyl cite); a server hook records idempotent usage events, stamping
last_recalled_at (exposure) and last_used_at (citation).
Usage drives both survival and consolidation priority — forgetting becomes
"unused = dead," and every later layer (decay tuning, distillation,
TeamMemBench utility) consumes this signal.
Apply temporal decay across the context/recall path (not just hybrid); confirm
consolidation scheduling; tune priority_decay and benchmark it
(FadeMem-style storage-reduction %, recall impact, write-path integrity). Turns the
self-named "honest gap" into a measured feature. Hard-depends on W6 —
tuning decay without a usage signal is tuning noise.
Enable the team scope across its three gates; ship team-management routes
+ CLI; wire team → memory-space; implement the SHARE/promote action with provenance and
attribution retained. Substrate, not coalescence yet.
sibyl export --format okf — one Markdown + YAML file per entity, edges as
Markdown links, the labeled-property-graph preserved losslessly via OKF-legal extension
frontmatter so the bundle is valid OKF for other tools yet round-trips back. ~2–4 days,
disproportionate payoff: "your memory stays yours, export in one command." And the
git-diffability is the feature: a scheduled export committed to a branch makes every
consolidation/decay/promotion cycle a reviewable diff — "what did the agent learn this
week" becomes git log, and memory gains a rollback story.
Land the doc-staleness reconciliation; keep benchmark-claim discipline; keep the AI-memory-landscape doc accurate (retrieval-vs-QA framing, forgetting/decay reality).
Published QA-accuracy and LongMemEval-V2 numbers with citable receipts; a regression gate
blocks PRs on quality drops; the cost/latency curve is published; the usage loop is
closed (cited-vs-uncited decay divergence demonstrated); forgetting is uniform,
usage-aware, and benchmarked; the team scope is enabled with proven
isolation, a way to create/populate teams, and a promote/SHARE path; OKF export ships
with the scheduled memory-changelog mode.
Turn the offline/online merge primitives into a live, provably-scoped, reversible, provenance-preserving team-memory coalescence engine — with a first-class data model and deterministic conflict states. Cross-user entity resolution is the field's unsolved problem; the differentiator is doing it without ever leaking scope and always reversibly. Contributors are writers, not just humans: the wedge is one operator running agent swarms — the same coalescence problem with zero privacy risk, dogfoodable on day one — and human teams land on the same records.
Before merging anything, define the model: canonical entity vs contributor aliases vs contributor assertions; an attribution schema; a conflict lifecycle with deterministic states (open / merged / superseded / contested); split/undo (every merge reversible); revocation semantics; redaction/anonymization transforms; and a human review UX for contested merges.
Unify online retrieval/dedup.py and offline migrate/merge.py
into a live cross-contributor entity-resolution + relationship-redirection engine
scoped to a team space, emitting the W1 records. Provenance-preserving — contributor
assertions are never destroyed.
Additive-safe vs conflict-checked write semantics (Letta-style
memory_insert / memory_replace); bi-temporal edge
invalidation for contradictions (Zep-style validity windows — invalidate, don't
delete). Deterministic conflict states, not silent merges.
Wire multi_user.py into a CI gate and define the load matrix explicitly:
N orgs × users/org, corpus size, QPS, concurrent writes, with cache/pool under stress
(more than surreal_graph_client_cache_size = 64 hot orgs). Replace the
57-record rehearsal with adoption-grade corpora; resolve the filtered-HNSW
recall@k=0.0 finding at scale.
Build the internal benchmark for cross-user entity resolution, concurrent multi-writer consistency, and "helped AND stayed scoped" (utility + access control + forgetting, GateMem-style). Dogfood seed: the eternia/macbook merge. Internal-only this release — publication waits for v1.3; synthetic-only risks "benchmark theater." The utility axis is outcome-grounded: tasks and memories share the graph, so "helped" means cited during tasks that completed — the ground-truth utility metric no public memory benchmark has.
Mechanical merge keeps N records; distillation compresses knowledge. A dream-cycle
stage maintains a distilled per-project handbook + wake summary (built with
synthesis_plan/draft/verify), regenerated when the graph changes enough.
Wake bundles serve the distilled artifact instead of raw top-k; the v1.1 usage signal
tells the distiller what earned prominence; the write-path-integrity gate applies to
the distiller too.
sibyl export --project + a session hook materialize the handbook + recent
context pack into .sibyl/memory/ read-only files. Filesystem-native
agents grep at zero marginal latency and survive server outages; citations still route
usage back over the API. Structured substrate, curated projection — Sibyl is
the governed source of truth behind the flat-file UX the frontier converged on.
Verbatim raws + lineage + a versioned extractor mean every extraction improvement can
replay over the whole historical corpus — memory quality compounds retroactively, a
property no competitor has. sibyl admin re-extract
--since-extractor-version re-derives, diffs against current, and scores the
delta with the v1.1 regression harness before promoting; supersession edges keep the
old derivation for rollback.
Reversible coalescence with deterministic conflict states and attribution, proven on the agent-swarm dogfood; isolation proven under concurrent load and revocation; internal TeamMemBench passing with a documented scale envelope and an outcome-grounded utility metric; distilled handbook + files projection serving wake bundles; one re-extraction replay executed end-to-end with a scored, gated delta.
Publish the benchmark the field lacks, and push the frontier — only from a position of proven isolation and honest numbers.
Only with a defensible dataset (real-team-log or a rigorously-justified hybrid) and at least one external comparator. Category-defining if done right; theater if rushed.
MAGMA-style multi-graph disentanglement (seam decided in v1.2); an optional cross-encoder reranker path for diffuse-evidence questions; belief-revision semantics (Kumiho/AGM) if observed conflicts justify it; procedural/skill memory; outcome-conditioned memory valuation — decay driven by task-outcome lift, the strongest form of "unused = dead."
Be the MCP-native, OKF-speaking backend behind Claude's /memories and
other agents; SurrealDB live queries → reactive UI; SurrealDB Cloud managed
multi-tenant; the Haven lighthouse integration; the adjacent Rust high-throughput
runtime.
An OKF importer (needs LLM edge-inference from prose links); watch the W3C "DataBook"
RDF/SPARQL profile as a better typed round-trip target than plain OKF. Keep
graph.json as the lossless internal archive; OKF is the portable public
projection.
Team-memory coalescence is isolation-correctness-under-merge: it cannot ship credibly without the harness (v1.1) to prove isolation and quality, and the eval gaps are table-stakes the field judges on. v1.1 also front-loads the honest-benchmark reputation before the v1.2 bet. v1.1's team substrate (scope enable + team CRUD + promote) is the minimum for v1.2's engine to stand on. Within v1.2, the reversibility/attribution model (W1) precedes the merge engine (W2) so nothing irreversible ships. The public benchmark waits for v1.3 because a bad dataset is worse than none.
Reuse project roles for teams, or define a distinct team-role set?
Hierarchical, tag-based, or both?
Real-team-logs (privacy-heavy), synthetic, or hybrid — this gates whether v1.3 publication is viable.
In scope for this arc, or explicitly out — org stays the hard boundary and team memory is within-org only?
Every load-bearing claim traces to a source. The 2026 preprints are new and often single-source — we treat their exact numbers as provisional and their structural findings as solid.