Remnic
Open-source, local-first memory and context for AI agents. One memory store, every agent.
Agenten stärken
Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
npx -y @remnic/[email protected]Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.
claude mcp add joshuaswarren-remnic -- npx -y @remnic/replit@9.69.56In einem Terminal ausführen.
{ "mcpServers": { "joshuaswarren-remnic": { "command": "npx", "args": [ "-y", "@remnic/[email protected]" ] } }}claude_desktop_config.json
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenWebsite: remnic.ai - guide library, comparisons, benchmarks, and changelog.
cat, grep, edit, and version-control your memory files with the tools you already use.Explain what helps once. Share only what you choose. Stop sharing at any time.
What Helps Me is a private support passport built on Remnic. It turns selected memories into short first-person cards. The owner reviews every word before a helper can see it.
No OpenAI API key is required. Manual cards need no model. Draft and question calls use the owner's existing Remnic route, including an OpenClaw gateway or a local model.
Watch the narrated 102-second product story or read the full Build for Good entry. The walkthrough always shows a Synthetic replay banner. It is not live-call proof. The separate live runner exercises the real standalone server and model flow. Its receipt validator checks internal consistency, not independent proof.
The framing comes from NHS England's health and care passport guidance. The NHS guidance says the person owns the passport, chooses its contents, and chooses who sees it. What Helps Me applies those rules to a broader self-advocacy tool. It is not a medical record, care plan, IEP, diagnosis tool, or emergency guide.
What Helps Me is for people who often need to explain how others can support them. It also helps trusted helpers act on clear, current guidance without seeing the person's full memory store.
The model is the scribe. The person is the author.
Codex traced Remnic's existing memory, model, HTTP, MCP, and browser contracts. It then built the feature as a seven-layer PR stack. Codex also wrote adversarial tests, checked WCAG states at four widths, and built the privacy-safe live run record. The owner approval and revocation rules remain deterministic core code. A model cannot bypass them.
Run the no-key synthetic walkthrough in about five minutes:
git clone https://github.com/joshuaswarren/remnic.git
cd remnic
pnpm install --frozen-lockfile
pnpm exec playwright install chromium
npm run demo:support-passport:replay
Open the printed loopback URL. The replay uses synthetic data and labels itself on every screen.
Run the standalone live flow with a local, direct, or compatible model route:
npm run demo:support-passport:live -- \
--config ./remnic.config.json \
--output ./tmp/support-passport-demo
npm run demo:support-passport:validate-receipt -- \
--receipt ./tmp/support-passport-demo/receipt.json
The validator checks the self-reported receipt schema and hash consistency. It does not convert that receipt into independent attestation.
For an existing OpenClaw install, keep the current gateway providers and model
auth. Enable the feature, owner HTTP bridge, and gateway route in
openclaw.json:
{
"plugins": {
"entries": {
"openclaw-remnic": {
"config": {
"modelSource": "gateway",
"openaiApiKey": false,
"supportPassport": { "enabled": true },
"agentAccessHttp": {
"enabled": true,
"host": "127.0.0.1",
"port": 4318,
"authToken": "${OPENCLAW_REMNIC_ACCESS_TOKEN}",
"principal": "passport-owner"
}
}
}
}
}
}
Set OPENCLAW_REMNIC_ACCESS_TOKEN to a private local bearer token. This token
protects the browser bridge. It is not a model provider key. Open
/remnic/ui/what-helps-me/ on the configured Remnic HTTP origin. Remnic uses
the OpenClaw gateway model chain and its existing provider auth.
The standalone live runner does not boot an OpenClaw host. Use the real browser
flow above to exercise an existing OpenClaw gateway setup. No OpenAI API key is
required. Manual cards and sharing need no model. Draft and question requests
return 503 provider_unavailable when no model route is configured.
Correct once. Every agent learns.
Remnic is shared memory for AI agents. Remnic Relay is the human-governed correction loop we built for OpenAI Build Week: it exposes the stale belief behind an agent failure, shows where that belief came from, puts the proposed replacement behind human approval, and proves a brand-new agent learned the approved correction from Remnic.
The demonstration follows an online-payment failure. One Codex agent reads the current rule while another confidently applies an older retry rule. Relay opens an evidence X-Ray connecting the recalled memory to the failing test, presents a before-and-after memory diff for approval, preserves the old belief as superseded, and then starts a fresh agent with no handoff. The mission is only complete when that agent recalls the replacement and turns the same payment test green.
Codex collaborated across the new extension: contract modeling, correction engine, Mission Control, isolated runner, adversarial tests, evidence sealing, and judge packaging. GPT-5.6 also powers the demonstrated product workflow itself through four isolated Codex roles: Scout reads the accepted rule, a Builder acts on stale memory, a correction agent proposes the replacement, and a fresh Builder proves the approved memory propagated without an agent handoff. Agents propose; a human approves; the test proves the result.
The fastest judge path uses the committed synthetic mission and requires no dependency install, model call, account, or credential:
git clone https://github.com/joshuaswarren/remnic.git
cd remnic
node scripts/relay/judge-package.mjs serve
Open the printed loopback URL, compare the current and stale beliefs, open the X-Ray, review and approve the proposed correction, and follow the fresh agent through the passing payment test. Verify the same evidence from the terminal:
node scripts/relay/judge-package.mjs verify
node scripts/verify-relay-judge-package.mjs
Remnic's core memory engine, integrations, and benchmark framework predate Build Week. The submission ledger separates that foundation from the new Relay work. See the judge guide and claim ledger for the complete evidence.
Most agents do not fail because they lack another prompt. They fail because they do not understand the user, the project, the boundaries, or what "good" means in context. Every session starts from zero: the agent forgets your name, your projects, the decisions you already made, and the bugs you already debugged. You re-explain the same context over and over, and the agent still repeats the same mistakes.
There is a useful split in AI memory between memory backends (extract facts, store vectors, retrieve relevant ones) and context substrates (human-readable context that accumulates and compounds across sessions). Most tools pick one camp. Remnic does both:
Most alternatives trade away at least one of local-first storage, a free license, or multi-host support; Remnic combines all three in one package.
Hosting and price labels mirror the canonical matrix at remnic.ai/compare, which also carries the per-competitor teardowns. Importers for mem0, Supermemory, ChatGPT, Claude, and Gemini: remnic.ai/import.
Install the CLI, start the daemon, and verify it is running.
npm install -g @remnic/cli # installs `remnic` (plus the legacy `engram` forwarder)
remnic init # write remnic.config.json
export OPENAI_API_KEY=sk-... # extraction provider (or route to a local LLM)
export REMNIC_AUTH_TOKEN=$(openssl rand -hex 32)
remnic daemon start # start the background server
remnic status # confirm it is running
remnic query "hello" --explain # test a query with the tier breakdown
remnic query --explain prints which retrieval tier produced each result and why, so you can watch the memory pipeline work on your very first query. Run remnic doctor any time to check your setup, then connect a tool from the table below. Full five-minute walkthrough: docs/guides/quickstart.md.
OpenClaw gets the deepest integration: a memory-slot plugin that recalls every session and observes every response.
openclaw plugins install clawhub:@remnic/plugin-openclaw # install the plugin
remnic openclaw install # wire the memory slot in openclaw.json
launchctl kickstart -k gui/$(id -u)/ai.openclaw.gateway # restart the OpenClaw gateway (macOS)
remnic doctor # verify every check passes
remnic openclaw install writes plugins.entries["openclaw-remnic"] and sets plugins.slots.memory = "openclaw-remnic" in ~/.openclaw/openclaw.json. Without the slot, OpenClaw skips plugin registration and no hooks fire, so remnic doctor checks the slot explicitly and points you at the fix. After the restart, confirm the plugin is live:
grep "gateway_start fired" ~/.openclaw/logs/gateway.log
A matching line means Remnic is active and hooks are firing. (The [engram] log prefix remains during the v1.x compatibility window.)
Prefer to let the agent do it? Tell any OpenClaw agent: "Install the @remnic/plugin-openclaw plugin and configure it as my memory system." It runs the install, updates openclaw.json, and restarts the gateway for you. Comprehensive install and first-run guide, including QMD setup: docs/getting-started.md.
One store, many front doors. Each integration reads and writes the same memory on your machine, so a preference you state in one tool is available in all of them.
Once the daemon is running, register each tool with a single command:
remnic connectors install codex-cli # token + connector state + memory extension
remnic connectors install claude-code # token + connector state
remnic connectors install pi # token + connector state
remnic connectors install omp # token + connector state
remnic connectors install replit # token + connector state
remnic connectors install droid # token + connector state + ~/.factory/mcp.json
Each install mints a host-specific auth token and records Remnic-side connector state; for some hosts (such as Codex CLI) it also materializes the memory extension. How much of the host itself gets configured varies — Claude Code and Hermes, for example, need a few manual wiring steps documented in their plugin guides. See the connector setup guide for every tool, exactly what its install automates, its config snippet, and multi-tenant setups.
Over MCP, Remnic exposes a rich tool surface beyond store and recall: entity lookup, memory correction, temporal recall, X-ray provenance, daily briefing, work-board, and continuity tools among them. Hosted clients call these directly, and the standalone HTTP endpoint (remnic daemon start or @remnic/server) serves the same tools. See the HTTP + MCP API reference.
Remnic runs a continuous three-phase loop around every agent conversation:
Recall -> Before a conversation, inject the relevant memories into context
Buffer -> After each turn, accumulate content until a trigger fires
Extract -> Periodically, distill structured memories with an LLM and write them to disk
flowchart LR
A[Agent session] -->|recall| B[Memory store<br/>markdown + YAML]
A -->|buffer turns| C[Extraction]
C -->|write memories| B
B -->|index| D[Hybrid search<br/>BM25 + vector + rerank]
D -->|rank + explain| A
Each memory is a portable markdown file with YAML frontmatter, so it stays git-friendly and readable with no database required:
---
id: decision-1738789200000-a1b2
category: decision
confidence: 0.92
tags: ["architecture", "search"]
---
Use the port/adapter pattern for search backends so alternative engines
can replace the default index without changing core logic.
Categories include fact, decision, preference, correction, relationship, principle, commitment, skill, and rule. Files are organized on disk under your configured memory directory:
<memoryDir>/
facts/ extracted facts, decisions, preferences, corrections, ...
entities/ people, projects, tools, and their relationships
profile.md the accumulated user profile
The search index lives separately and is rebuildable from these files at any time. The full storage model and retrieval flow are in docs/architecture/overview.md.
Core memory. LLM extraction that separates durable knowledge from conversational noise, entity tracking for people, projects, tools, and relationships, a full write/consolidate/expire lifecycle, and importance gating that drops low-value facts before they are ever stored. See docs/architecture/memory-lifecycle.md.
Search. Six pluggable backends behind one interface: QMD, Orama, LanceDB, Meilisearch, a remote adapter, and a no-op. QMD is the default and highest-quality option, combining BM25, vector, and reranking. Any backend is rebuildable from your markdown at any time. See docs/search-backends.md.
Memory OS. Namespaces for multi-agent and multi-tenant isolation (opt-in via namespacesEnabled, default false), hot/cold tiering driven by a value-score model, background consolidation via the "dreams" surface, opt-in graph reasoning with Personalized PageRank, and transparent AES-256-GCM at-rest encryption (opt-in via secureStoreEnabled, default false).
Lossless Context Management. Archive full session transcripts and recall them losslessly through the daemon recall envelope, for when a summary is not enough. Opt-in via lcmEnabled, default false. See docs/guides/lossless-context-management.md.
Trust and boundaries. Scoped memory, provenance on every fact, correction handling, and boundary principles that decide when an agent should ask instead of act. See docs/user-aware-agents.md.
Import your memory. Seven optional importers pull existing memory from the tools you already use. The base CLI never bundles them; install only what you need, and every run supports --dry-run for a zero-write preview.
See docs/importers.md for input formats, provenance metadata, and the full privacy breakdown.
Open Knowledge Format (OKF). The memory directory doubles as an OKF v0.1 knowledge bundle: every memory file ships an inert type field next to Remnic's canonical category, so OKF-aware consumers can read your store without a converter. category stays authoritative — type is interop metadata and never overrides it on parse. Two commands keep the bundle conformant:
Config gates, lint finding codes, and the full category-to-type mapping: docs/okf.md.
Live connectors: Google Drive and Notion. Beyond one-time imports, Remnic can continuously sync external sources into memory. The Google Drive and Notion connectors poll for changed documents on a schedule and ingest them incrementally — connect once (remnic connectors run google-drive / remnic connectors run notion for a manual sync, remnic connectors status to inspect), and your docs stay searchable alongside everything else your agents know. Gmail and GitHub connectors run on the hosted scheduler as well. Setup, OAuth, and polling details: docs/live-connectors.md.
Wearables. Three optional connectors ingest AI-wearable recordings, clean and speaker-label the transcripts, apply your personal corrections, store searchable per-day transcript files, and create memories under strict per-source trust gates: @remnic/connector-limitless (Limitless Pendant), @remnic/connector-bee (Bee bracelet), and @remnic/connector-omi (Omi necklace). See docs/wearables.md.
Glass-box tooling. Recall X-ray shows which retrieval tier produced each result and why, the daily briefing surfaces active entities and open commitments, and the operator console gives live engine introspection with trace record and replay.
Benchmarks. Memory quality is measured, not asserted. MemCorrect checks whether a backend recalls the right fact, accepts a correction, and stops serving the stale one. The full benchmark suite covers the rest, with reproducible artifacts and leaderboard safety.
More capabilities. A few of the deeper features, each with its own guide:
conservative preset).valid_at / invalid_at fact lifecycle and an as_of recall filter.Local-first is a trust feature, not a tagline.
--dry-run on imports to preview without writing.facts/, entities/, profile.md) should never be committed. Enable at-rest encryption if the disk itself is untrusted.Remnic is a pnpm monorepo of 25+ published packages. The engine is host-agnostic; every integration is a thin adapter over it, so standalone Remnic is always first-class and adapter work follows each host's upstream SDK rather than recreating host behavior inside Remnic.
@remnic/core
(extraction, storage, search,
graph, trust, consolidation)
|
+-------------------+-------------------+
| | |
@remnic/cli @remnic/server plugins
(remnic bin) (HTTP + MCP) openclaw, claude-code,
codex, pi, hermes
|
a la carte add-ons
import-* (7 importers) + connector-*
(3 wearable sources)
@remnic/core (the framework-agnostic memory engine), @remnic/cli (the standalone remnic binary), and @remnic/server (HTTP + MCP server).remnic-hermes on PyPI.@remnic/import-* importers and three @remnic/connector-* wearable connectors, installed only when you need them.@remnic/bench provides the published suites and CI regression gates.The complete package map, dependency graph, and publish order are in docs/architecture/monorepo-structure.md.
Remnic is zero-config by default: remnic init writes a working remnic.config.json and every subsystem ships a sensible default. When you need control, there are hundreds of options grouped under four presets, selectable with a single memoryOsPreset key:
conservative — minimal footprint, extraction judge and heavier features off.balanced — the general-purpose default.research-max — every quality feature enabled, highest cost.local-llm-heavy — tuned for local-model extraction and rerank.Extraction routing (gateway, OpenAI, or a local LLM), recall budget, search backend, lifecycle, namespaces, and encryption are all configurable. Every setting, its default, and operator guidance live in docs/config-reference.md.
Running Remnic for a team or across machines? remnic daemon start hands off to launchd or systemd when a service is installed, and @remnic/server exposes the same memory over HTTP + MCP for remote agents. Namespaces isolate tenants, and the standalone server supports multi-tenant, multi-harness setups.
The complete, organized docs hub lives at docs/README.md. Starting points by journey:
The website publishes the guide library (what is AI agent memory, MCP memory servers, Claude Code memory), the comparison pages, the benchmarks report, and the changelog.
Do I need OpenClaw? No. Remnic runs standalone through @remnic/cli and connects to any tool over MCP or HTTP. OpenClaw simply gets the deepest native integration.
Does it work offline or without an API key? Retrieval works with no provider at all. Extraction needs a model, but you can route it to a local LLM to keep everything on-device.
Where is my data? In markdown files under your configured memory directory. Nothing leaves your machine except during extraction with a remote provider, or when a hosted client reads memories through Remnic's tools.
How much does it cost? The software is MIT and free. Your only cost is your chosen extraction provider, which is zero when you use a local LLM.
Do I need QMD? No, but it gives the best search. Without it, Remnic falls back to embedding search and then recency-ordered reads.
Can multiple agents share one memory? Yes. Every connected tool reads and writes the same store, and namespaces isolate tenants when you want separation.
Is it production-ready? Remnic is extensively tested with CI regression gates and a published benchmark suite. See docs/benchmarks.md for the evidence.
I was using Engram. Everything still works. See Engram to Remnic below for the migration path.
Engram is now Remnic. Canonical packages live under the @remnic/* scope, and OpenClaw installs use @remnic/plugin-openclaw. The legacy engram CLI name, the openclaw engram command namespace, and the /engram/v1/... HTTP paths remain available as a compatibility surface during the rename window. Migrating an existing install? Run remnic openclaw migrate-engram --yes, which backs up the legacy extension, installs the new plugin, preserves your memoryDir, and switches the memory slot. Full steps: Engram to Remnic migration guide.
Every bit of support helps keep Remnic alive and free. If you are able, sponsor on GitHub or send a Lightning donation to [email protected] to directly fund continued development and new integrations.
If financial support is not an option, you can still make a big difference: star the repo, share it, or recommend it to a colleague. Word of mouth is how most people find Remnic.
Contributions from humans and AI-assisted contributors are welcome. Start with CONTRIBUTING.md for setup, the preflight gate, and PR expectations. Deeper references: docs/development/contributing.md and docs/CONVENTIONS.md.
Open-source memory and context for user-aware agents: scoped memory, provenance, retrieval quality, correction, boundaries, evals, and MCP/HTTP access.
{ "mcpServers": { "joshuaswarren-remnic": { "command": "npx", "args": [ "-y", "@remnic/[email protected]" ] } }}Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Remnic läuft lokal über stdio.
Zuletzt geprüft: 2026-11-17. Open-source memory and context for user-aware agents: scoped memory, provenance, retrieval quality, correction, boundaries, evals, and MCP/HTTP access.