Roadmap

Quaid moves through three arcs. Each arc is a directional bet, not a feature list. The phases inside each arc have hard ship gates: no phase begins until the previous one passes.

The shape of the bet

Arc 1 ships a private, offline knowledge runtime that holds. Arc 2 turns that runtime into an agent that compounds knowledge across sessions. Arc 3 turns that compounding into something that genuinely thinks. Each arc is independently useful; together they are the whole product.

---

Arc 1 - Local memory that holds Shipped

The foundation. Storage that doesn’t lose data, retrieval that doesn’t hallucinate, and a sync engine that follows your editor without dropping writes. This arc is complete.

Sprint 0 - Repository scaffold

Complete

Outcome: a binary the team can ship. Cargo workspace, schema v4 DDL, CI/release workflows.

Phase 1 - Storage, CLI, search, MCP

Complete

Outcome: a memory you can read, write, and query without a network. Import, export, FTS5 + vector hybrid search, 5 core MCP tools. Released as v0.1.0.

Phase 2 - Intelligence layer

Complete

Outcome: links, contradictions, and progressive retrieval that survives token budgets. Temporal links, assertions, contradiction detection, 16 MCP tools. Released as v0.2.0.

Phase 3 - Skills, benchmarks, polish

Complete

Outcome: workflow logic that ships in the binary, plus a regression gate that catches retrieval drift. All 8 skills production-ready, BEIR regression gate, benchmark harnesses (LoCoMo, LongMemEval, BEAM adapters). Released as v0.9.2.

Phase 4 - vault-sync engine

Complete

Outcome: memory that stays current as you edit in Obsidian or any editor, with write-safety interlocks under concurrent agents.

Landed: Collections model (quaid collection add/list/info/sync/remove); .quaidignore with atomic validation and live reload; quarantine lifecycle (list/export/discard; Unix narrow restore with no-replace contract); Unix CAS write interlocks plus crash-safe sentinels; live file watcher with 1.5s debounce (macOS/Linux); UNIX-socket single-file write proxying; restore/remap two-phase safety pipeline; UUID lifecycle and opt-in write-back (migrate-uuids); memory_collections MCP tool; background embedding queue and worker.

Deferred to future work: Full IPC proxy for bulk rewrites; online restore handshake; Windows quarantine restore. See the Deferred section below.

---

Arc 2 - Agents that compound In progress

Phase 5 ships conversation memory and a local Phi-3.5 Mini SLM that extracts structured facts from conversation turns ΓÇö airgapped, downloaded once, never calls home. Namespace isolation and supersede chains are live. Phase 6 adds the entity layer that turns extracted facts into a queryable knowledge graph.

Honest about today

Pre-implementation baselines (before Phase 5): LongMemEval: Quaid 0.0% → Mem0 v3 93.4% LoCoMo: Quaid 0.1% → Mem0 v3 91.6%

Phase 5 (conversation turn ingestion, Phi-3.5 Mini SLM extraction, supersede chains, head-only retrieval by default) is now shipped. These benchmarks have not yet been re-run against the Phase 5 implementation. Targets after Phase 5 + Phase 6 entity work: LongMemEval > 40%, LoCoMo > 40%.

Phase 5 - Conversation memory + SLM extraction

Outcome: an agent that remembers the right things from a conversation turn, not just the turn itself.

Namespace isolation

Complete

Per-namespace memory isolation for multi-agent and multi-session contexts. Drops LongMemEval benchmark runtime from 3-6 hours to under 30 minutes.

→ GitHub #137

Large corpus performance

Pending

Optimize for 10K+ document stores. Current import: ~437s for 350 docs. Target: under 60s. Validate Quaid at the scale real users need (GBrain operates at 75K files).

→ GitHub #134

Conversation ingestion + SLM extraction

Complete

Ingest conversation turns, extract structured facts using a local Phi-3.5 Mini SLM, store as typed pages. Non-blocking background queue, fully airgapped. Supersede chains, head-only retrieval by default, memory_add_turn / memory_close_session / memory_close_action MCP tools, correction-via-file-edit path.

→ GitHub #105

Contradiction resolution

Complete

Supersede and version stale facts. “I used to work at X, now Y” resolves correctly rather than keeping both facts active. Version chains, temporal-latest query mode. Per-fact dedup/supersede/coexist resolution with embedding-backed scoring.

→ GitHub #135

Phase 6 - Knowledge graph

Outcome: query by entity, not just text. Once Phase 5 extracts entities, the graph is a thin layer on top.

Entity extraction at write time

Graph foundation

Extract people, companies, and concepts at ingest time using zero-LLM heuristics. Coordinates with #105 - shares the same SLM extraction pipeline.

→ GitHub #107

Self-wiring knowledge graph

Depends on #107

YAML frontmatter as first-class graph edges. Documents auto-link via wikilinks and tags. From GBrain data: +28% graph search performance, -53% noisy results.

→ GitHub #72

Graph traversal query API

Depends on #72, #107

Query by entity: memory_graph_query(entity, hops). Find all pages connected to X, find concepts that link two people, 2-hop traversal in under 500ms.

→ GitHub #133

Multi-hop graph traversal

Depends on #133

Configurable 1-3 hop traversal, edge type weighting, relationship scoring combined with semantic similarity.

→ GitHub #74

---

Arc 3 - Memory that thinks Later

The features that turn a memory store into a memory system. With the graph built and conversation memory working, the runtime can be proactive instead of just responsive.

Phase 7 - Intelligence layer

Outcome: memory that updates itself when new content arrives, deduplicates noise at scale, and compresses what it sends to an LLM.

Active memory enrichment

Depends on #107, #133

When new content arrives, existing entity memories update proactively. GBrain v0.23.0’s headline feature: “Your brain actually gets enriched from your conversations.”

→ GitHub #136

Noise reduction + deduplication

Result deduplication and relevance filtering. Implementable at any point but most valuable when the corpus is large.

→ GitHub #75

Context compression (REFRAG)

Compress retrieved chunks before sending to an LLM. Reduces tokens and cost while maintaining quality. High value at production scale.

→ GitHub #76

---

Build order summary

For contributors. The arcs above are the public roadmap; the table below is the remaining implementation order for incomplete work.

Priority	Issue	Feature	Depends on
1	#134	Large corpus performance	-
2	#107	Entity extraction	#105 (coordinate)
3	#72	Self-wiring knowledge graph	#107
4	#133	Graph traversal query API	#72, #107
5	#74	Multi-hop traversal	#133
6	#136	Active memory enrichment	#107, #133
7	#75, #76	Noise reduction, context compression	Any

---

Deferred

These are known design choices, not oversights.

Feature	Status	Reasoning
npm, Homebrew, winget	Planned	Registry ownership and release automation not yet in place
WASM compilation	Possible	Strong Rust support, not yet a priority
Collaborative / multi-user	Not planned	Single-writer by design. No auth, RBAC, or CRDTs.
LLM-assisted contradiction detection	Deferred	Binary stays dumb. Cross-page reasoning lives in the maintain skill.
Room-level palace filtering	Deferred	Wing-only until benchmarks prove room-level helps.
vault-sync IPC proxy (bulk rewrites)	Deferred	Full multi-file write proxying to v0.14.0+; current surface is single-file UNIX socket only.
Online restore handshake	Deferred	Requires live serve+CLI coordination with crash-durable guarantees; CLI narrow restore shipped for Unix offline use.
Windows quarantine restore	Deferred	Unix narrow no-replace restore shipped; Windows path requires separate design work.