remnic

Remnic

Open-source, local-first memory and context for AI agents. One memory store, every agent.

Website: remnic.ai - guide library, comparisons, benchmarks, and changelog.

• Your files, your machine. Every memory is a plain markdown file with YAML frontmatter on your disk. No database, no cloud dependency, no subscription. cat, grep, edit, and version-control your memory with the tools you already use.
• One memory across every tool. OpenClaw, Claude Code, Codex CLI, Cursor, ChatGPT (developer mode), Hermes, Replit, Pi, omp, Factory Droid, and any MCP client read and write the same store. Tell one agent a preference; every agent knows it.
• Automatic extraction and recall. Remnic watches conversations, distills durable knowledge, and injects the right context back when it is needed.
• Sharp retrieval. Hybrid search (BM25 + vector + reranking) over rebuildable indexes, with graph recall, memory-worth scoring, and per-result provenance you can inspect.
• MIT licensed. Free, open, and built to be forked.

Build for Good 2026: What Helps Me

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.

What we built

• An owner workspace for selecting exact memories, drafting cards, editing each draft, and approving each card.
• Exact-version share links that last from five minutes through seven days.
• A helper view that shows approved cards only and cites the card behind each grounded answer.
• Immediate Stop sharing controls. Every helper request checks durable grant state again.
• A provider-neutral model path. It uses Remnic's existing OpenClaw gateway, local, compatible remote, and optional direct OpenAI routes.
• A strict live run record for draft, approval, sharing, question, revocation, and the final locked read. It stores no private text, secrets, or raw model IDs.

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.

Who it helps

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.

How it will be used

1. The owner selects one to 20 notes.
2. The owner checks a clear consent box or writes a card by hand.
3. The configured model drafts up to eight cards.
4. The owner edits and approves each card.
5. The owner shares exact card versions for a set time.
6. The helper reads the guide or asks a grounded question.
7. The owner selects Stop sharing to lock the link.

The model is the scribe. The person is the author.

How Codex helped

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.

How to run the project

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.

OpenAI Build Week 2026: Remnic Relay

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.

What we built during Build Week

• a versioned contract for conflicts, evidence, corrections, lineage, and fresh-agent verification;
• a human-gated correction engine with append-only supersession;
• Mission Control views for conflict inspection, evidence X-Ray, approval, propagation, and the final mission receipt;
• an isolated four-role Codex mission runner using only a cleared synthetic Remnic instance; and
• a dependency-free judge package that binds the recorded agent run, product UI, synthetic fixture, and verification receipt into one reproducible story.

How Codex and GPT-5.6 were used

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.

Install, supported platforms, and testing

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

• Judge package: Linux with procfs and Node.js 22.12 or newer; Linux x64 is independently clean-room verified.
• Mission Control: Chrome/Chromium 151 verified at desktop and mobile sizes, including keyboard-only and reduced-motion flows.
• Live isolated mission runner: Linux x64 with Codex CLI 0.144.4 or newer and the repository development dependencies. This is not required for the judge experience.
• macOS and Windows: use the submission video/gallery or run the verifier in a supported Linux environment. The executable verifier fails closed where equivalent filesystem-safety primitives are unavailable.

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.

Why Remnic

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:

• The files are the source of truth. The hybrid search index is downstream of your markdown, fully rebuildable from disk, never authoritative itself.
• Recall stays sharp. Three retrieval tiers, opt-in graph traversal, memory-worth scoring that filters low-value facts before they reach the model, and temporal supersession that keeps stale facts out.
• It compounds. Background consolidation merges duplicates, promotes recurring themes, and snapshots page versions on every overwrite. The longer you use it, the better it gets, and you can always read exactly what it knows.

Without Remnic	With Remnic
Re-explain who you are and what you are working on	The agent recalls your identity, projects, and preferences automatically
Repeat context for every task	Entity knowledge surfaces people, projects, tools, and relationships on demand
Lose debugging and research context between sessions	Past root causes, dead ends, and findings are recalled, so work is not repeated