Remnic Agent Memory
Shared, inspectable, local-first memory for AI agents across tools and sessions.
Per-dimension scores and reasoning
The evidence shows a local Markdown source of truth; sensitive networking, WebDAV, namespaces, graph reasoning, and encryption are opt-in. Connectors mint host-specific tokens, CI workflows declare narrowed permissions, retrieval exposes provenance, imports support dry-run, and overwrite/correction flows retain snapshots or append-only history. Deductions apply because ordinary automatic extraction and writes do not show per-operation user confirmation, secure storage is disabled by default, and the supplied material does not fully specify what content remote model providers receive or how it is redacted. Dependency evidence includes a pinned pnpm version, frozen-lockfile instructions, and a security policy, but no lockfile, audit result, or complete supply-chain controls. Author, repository, license, and memory attribution are clear; unknown publisher identity is not treated as suspicious.
The README, package metadata, and security policy describe a coherent product, requirements, fallback behavior, and interfaces. However, SECURITY.md identifies 9.6.x as the supported line while package.json reports 9.69.85, indicating documentation drift and preventing a full self-consistency score. Missing QMD has documented fallback behavior, absent model routing yields an explicit 503, and doctor, status, explain output, and fail-closed workflow notices provide useful failure messages. Dependency availability is deducted because actual health and compatibility across numerous providers, search backends, and hosts are asserted rather than established by the supplied static evidence.
The material distinguishes general memory, support-passport sharing, correction propagation, and retrieval-only operation, with local, OpenClaw, MCP, HTTP, and pluggable-backend configurations. Boundaries are unusually explicit: the passport is not a medical record, diagnosis, care plan, or emergency guide, and synthetic replay, live operation, and independent attestation are separated. Recall, buffering, extraction, per-turn, and on-demand modes are described, but implementation evidence for all capture thresholds, false-trigger suppression, and user overrides is absent, so trigger precision is not full. Platform, Node, browser, and Linux constraints are concrete.
The README has strong navigation through quick starts, architecture, storage layout, integration tables, feature references, and runnable examples. The MIT text matches package metadata, while platform limits, no-provider behavior, synthetic-evidence caveats, and security reporting are explicit. Deductions apply because remnic and legacy engram names coexist during a compatibility window; the changelog is mainly referenced on an external site rather than supplied as revision-local history; and maintenance responsibility is identifiable through Joshua Warren, issue metadata, and the advisory channel but lacks a verified organizational publisher, stated response targets, team ownership, or succession path.
Human-readable shared memory, rebuildable indexes, cross-host access, provenance inspection, correction, and revocation constitute directly usable output and meaningful value beyond ordinary session memory. No-key retrieval, local-model routes, and fallbacks reduce entry cost. Cost-benefit is deducted because claims such as sharper retrieval and improvement over time are primarily project assertions, while the supplied evidence lacks sufficient benchmark results, resource measurements, model-call costs, and operational-cost analysis.
Explain output, per-result provenance, X-Ray views, correction lineage, a claim ledger, and receipt mechanisms support traceability. The README carefully says that receipts validate internal consistency only and that synthetic replay is neither live-call evidence nor independent attestation, earning strong fact/inference separation. Deductions apply because broad quality, compatibility, and competitor claims are not cross-validated by the supplied implementation excerpts or independent sources; the provided benchmark fixture only checks a synthetic event queue and does not corroborate core memory performance.
- Secure storage and namespace isolation are disabled by default; explicitly enable and validate encryption, scoping, and filesystem permissions before storing private conversations or multi-tenant data.
- Automatic extraction may send conversation content to configured remote model providers; verify data flow, retention, log redaction, and credential isolation before deployment.
- The 9.6.x support statement in SECURITY.md conflicts with package version 9.69.85; confirm the actual supported release line before upgrading or reporting vulnerabilities.
- Several quality, benchmark, and compatibility claims lack independent corroboration in the supplied material; synthetic demos and self-reported receipts are not production validation.
- The AI review workflow has checks:write and issues:write permissions and references third-party Actions by version tags; maintainers should confirm necessity and consider commit-SHA pinning.
What does this agent do, and when should you use it?
Remnic is a local-first memory and context system that treats Markdown files with YAML frontmatter as the source of truth and its search indexes as rebuildable derivatives. Its main components are @remnic/core, @remnic/cli, and the HTTP/MCP service @remnic/server, supplemented by adapters for OpenClaw, Claude Code, Codex CLI, Pi, Hermes, and other clients. Before a conversation it retrieves and injects relevant memories; afterward it buffers turns and uses a configured model route to extract durable facts, decisions, preferences, corrections, and relationships. Retrieval can combine BM25, vectors, reranking, temporal supersession, and optional graph traversal, with provenance and tier explanations for individual results. The memory store remains on the operator's machine by default, although remote extraction providers and hosted clients receive the content sent through their respective paths. It is a strong fit for developers or teams that need cross-tool continuity without handing the authoritative memory store to a hosted memory service.
Remnic runs a Recall → Buffer → Extract loop around agent conversations. Recall reads Markdown memories and entity records from the configured memoryDir, searches them through QMD, Orama, LanceDB, Meilisearch, a remote adapter, or documented fallback paths, and injects a budgeted context slice. Buffer collects conversation turns until a size or time trigger fires. Extract then calls the OpenClaw gateway model chain, the OpenAI Responses API, or a local LLM; accepted knowledge is written under facts/, entities/, or profile.md, after which the index is rebuilt. Its lifecycle includes importance gating, consolidation, version snapshots, correction records, temporal supersession, valid_at/invalid_at filtering, namespaces, and optional Personalized PageRank graph recall. remnic query --explain, Recall X-ray, daily briefing, and the operator console expose retrieval and runtime evidence. Through @remnic/server, HTTP and MCP clients can invoke storage, recall, entity lookup, correction, temporal recall, provenance X-ray, work-board, and continuity operations against the same store.
- A developer moving between Codex CLI, Claude Code, and Cursor who wants project conventions, debugging findings, and preferences to follow them across tools.
- A long-lived software team that needs architecture decisions and corrections to retain provenance while preventing superseded rules from being recalled as current.
- A privacy-conscious individual who wants memory stored as readable, editable files under their own filesystem controls.
- A self-hosting team serving several agents or tenants that needs namespace isolation and a common HTTP/MCP memory service.
- An engineering group evaluating memory quality with MemCorrect and the published benchmark framework, including whether stale facts disappear after correction.
- A user migrating saved context from ChatGPT, Claude, Gemini, mem0, or Supermemory who wants a dry-run before any imported memory is written.
What are this agent's strengths and limitations?
- Authoritative memories are ordinary Markdown and YAML files that operators can inspect, edit, back up, and use to rebuild every search index.
- Native integrations for several coding-agent hosts plus generic HTTP/MCP access let multiple tools share one memory store.
- Hybrid retrieval, reranking, correction handling, temporal supersession, and per-result provenance directly address stale or poorly grounded recall.
- Namespaces, optional AES-256-GCM encryption, boundary principles, and dry-run imports provide concrete governance and isolation controls.
- Extraction is not tied to one model vendor: documented routes include OpenAI, the OpenClaw gateway, and local models, while retrieval requires no provider.
- Adoption requires Node.js 22.12 or newer and an operating daemon or server; some host integrations still need manual configuration after connector installation.
- Automatic extraction requires a configured model route. Remote routes introduce provider cost and data transfer, while unconfigured model-dependent requests can fail with 503 provider_unavailable.
- The highest-quality hybrid search depends on optional QMD; fallback embedding or recency-based retrieval is not equivalent.
- Namespaces, at-rest encryption, graph reasoning, and Lossless Context Management are opt-in rather than default protections.
- Memory files contain user data and must be kept out of Git; adopters remain responsible for filesystem permissions, secure backups, and deciding what hosted clients may read.
How do you install or deploy this agent?
Install Node.js 22.12 or newer, then run:
npm install -g @remnic/cli
remnic initexport OPENAI_API_KEY=sk-...
export REMNIC_AUTH_TOKEN=$(openssl rand -hex 32)
remnic daemon start
remnic status
remnic query "hello" --explainThe OpenAI key is one supported extraction route, not a mandatory provider choice; an OpenClaw gateway or local LLM can be configured instead. Retrieval-only operation needs no model provider. QMD is optional but recommended for the highest-quality hybrid search; without it, Remnic falls back to embedding search and then recency-ordered reads.
How do you use this agent?
With the daemon running, use remnic query "your query" --explain to inspect results and their retrieval tiers, and run remnic doctor to validate the installation. Connect Codex CLI with remnic connectors install codex-cli; corresponding targets exist for claude-code, pi, omp, replit, and droid. Connector installation mints a host-specific authentication token and records connector state, although some hosts still require manual wiring documented in their integration guides. For OpenClaw, run openclaw plugins install clawhub:@remnic/plugin-openclaw followed by remnic openclaw install, then restart the gateway; the installer configures the plugin entry and memory slot. Other clients can call the memory operations on demand through the stdio or HTTP MCP endpoint served by @remnic/server or remnic daemon start.
How does this agent compare with similar options?
The project positions Remnic as combining local-first storage, an MIT license, and multi-host coverage. Its comparison matrix describes mem0, Letta (MemGPT), and Zep (Graphiti) as cloud or self-hosted alternatives accessed through SDKs or APIs and backed by vectors or databases; Supermemory is listed as a paid cloud service, MemPalace as a free single-host local option, and ChatGPT memory as opaque cloud storage confined to one tool. Remnic differentiates itself with Markdown and YAML as the authoritative store plus native adapters and generic MCP access. These are the repository's stated product comparisons rather than independent benchmark findings.