Skip to content
Memory & Intelligence Layer · v8.5.4 · Local-First · Free to Use

Your AI Forgets Everything. Wyrm Remembers, and Learns From Failure.

The local-first memory and intelligence layer for AI agents. It gives Claude, Cursor and Copilot persistent memory across every session, plus a benchmarked firewall that blocks a known mistake before it repeats. Nothing leaves your machine. Free to use.

100% / 100% recall / precision firewall·Local-first · nothing egresses·Measured, not claimed·No account · works offline

Or install the CLI: npm install -g wyrm-mcp

New here? 5-minute Getting Started · Questions or ideas? GitHub Discussions

Works with

Claude Desktop·GitHub Copilot·Cursor·Windsurf·Any MCP Client
NVIDIA Inception Program member badge

Ghost Protocol is a member of the NVIDIA Inception program

Pricing

Free Forever. Scale When Ready.

Local use is free with no limits. Paid plans add cloud sync, encryption, and team collaboration.

Free

For individual developers

  • Local SQLite storage
  • All 137 tools · 32-verb surface
  • Fleet memory + negative learning
  • Write receipts + trust lanes
  • Live Memory + hybrid recall
  • Cross-project memory
  • Full-text + semantic search
  • Unlimited projects
  • Community support
Most Popular

Pro

For power users

  • Everything in Free
  • Cloud sync across devices
  • AES-256 encryption
  • Priority support
  • Advanced analytics
$29
/month
Subscribe

Team

For development teams

  • Everything in Pro
  • Shared team memory
  • Up to 25 seats
  • Admin dashboard
  • Slack integration
$199
/month
Subscribe

Enterprise

For organizations

  • Everything in Team
  • Unlimited seats
  • SSO / SAML
  • Custom SLA
  • Dedicated support
  • On-premise option
$499
/month
Subscribe

Need a custom plan? Contact us →

The Problem

AI Has Amnesia

Context window limits mean your AI starts fresh every session. You re-explain your codebase, preferences, and decisions over and over. The workarounds (copy-paste, prompt files, manual context) are all fragile.

The Solution

Wyrm Gives Your AI a Permanent Brain

Wyrm is a Model Context Protocol (MCP) server: the memory and intelligence layer that gives AI agents persistent, searchable memory. Projects, sessions, quests, skills, and arbitrary data, indexed with hybrid full-text and semantic recall and available across every conversation. Local-first and private. Your memory stays on your machine, built on the Wyrm Memory Protocol. The free tier needs no account and no login, and works fully offline. See how Wyrm compares to other AI-memory tools or read the docs.

Projects & sessions that persist forever
Hybrid recall: full-text fused with semantic vectors
32-verb typed surface: 137 tools, all callable
Knowledge graph with entity relationships
Ground truths & scaffolds for every context build
Unified capture: one tool classifies anything
Session prime: full context in one call
Run-attributed fleet memory (agent_id, run_id)
Fleet negative learning: one failure blocks it for all
Benchmarked firewall: 100% recall / 100% precision
Write receipts: nothing lost silently
Provenance trust lanes + injection quarantine
Temporal + graph recall beside recency
Portable skills synced across every machine
wyrm render: memory into CLAUDE.md at zero MCP tokens
Install
$ npm install -g wyrm-mcp
claude_desktop_config.json
{
  "mcpServers": {
    "wyrm": {
      "command": "wyrm-mcp"
    }
  }
}

Up and running in under 60 seconds. Full setup guide →

Features

Everything Your AI Needs to Remember

A frozen 32-verb typed surface over 137 tools: run-attributed fleet memory, fleet negative learning, hybrid recall (with optional NVIDIA NIM embeddings and reranking), the knowledge graph, Live Memory replication, provable writes with receipts, provenance trust lanes, and the render target. The load-bearing twelve are below; the full surface is in the docs.

Persistent Memory

Projects, sessions, quests, skills, ground truths: everything kept across every session, local-first.

Hybrid Recall

Full-text (FTS5) fused with semantic vectors and an optional cross-encoder rerank. Local nomic by default; opt into NVIDIA NIM embeddings + reranker for a sharp recall lift, nothing egresses unless you say so.

Benchmarked Firewall

Negative learning, measured: 100% recall / 100% precision blocking a repeated mistake, ~0.1 ms, deterministic. The benchmark ships in the repo.

Fleet Memory

Every write is attributed to the (agent_id, run_id) that produced it, so a swarm of agents shares one accountable memory bus.

Fleet Negative Learning

A failure recorded by one agent blocks the repeat for every sibling, enforced by the wyrm-guard hook before the doomed call runs.

Knowledge Graph

Entity/relationship graph with neighborhood traversal, path finding, and merge. Memory with structure, not just search.

Frozen 32-Verb Surface

A stable, typed verb surface (structuredContent + annotations) an orchestrator can pre-check. 32 advertised verbs; 137 tools all callable.

Portable Skills

SKILL.md content syncs end-to-end across every machine. Teach a skill once; the whole fleet inherits it.

Render Target

wyrm render compiles your memory straight into CLAUDE.md, AGENTS.md, Cursor and Copilot slots: byte-stable, budget-capped. Casual sessions cost zero MCP tokens.

Provable Memory

Every write returns and ledgers a receipt: stored, queued, merged, or dropped, and why. wyrm digest --writes reconstructs any day offline, so nothing is lost silently.

Provenance Trust Lanes

Every memory is marked by origin. Untrusted content is quarantined and categorically withheld from context briefs, so a planted instruction in a transcript can never be read back as a command.

Temporal & Graph Recall

Recall ranks on temporal, usefulness, and knowledge-graph signals beside recency, not just keyword and vector overlap.

Stay in the Loop

Get Updates. Shape Wyrm.

New features, setup tips, and the occasional offer. No noise. Building with Wyrm? Join the dev circle for early access and exclusive perks.

New here? Get your AI using Wyrm properly

Stop Losing Context. Start Remembering.

Give your AI the memory it deserves. Free to use, local-first, and ready in 60 seconds.

Read the Docs

Built by Ghost Protocol, the studio that ships security tools that actually work.

Changelog
v8.5.4Latest

Fleet-safe sync, prime that lands on the right project

The 8.5 line hardens the sovereign cloud fleet: a mis-keyed push is quarantined and skipped instead of wedging every device's sync, login fails loud (naming the fix) when a key cannot read the account, and the daemon keeps its configured interval across restarts. Session prime now resolves the project that owns the server's working directory, so a session on one project can never hijack another project's memory brief.

v8.0.1

Injection quarantine hardening

A full garak red-team (622 real jailbreak payloads) fired at the memory-brief surface. Untrusted-origin content is now categorically withheld from context briefs, so a planted instruction in a transcript can never be read back as a command. The detector catches 80.7% of the corpus with zero false positives, and it ships as a CI gate.

v8.0.0

PROOF: memory you can prove

The v8 major. Every write now returns and ledgers a receipt (stored, queued, merged, or dropped, and why), and wyrm digest --writes reconstructs any day offline. Harness memory files become compiled views of Wyrm via wyrm bridge, and wyrm metabolize supersedes duplicates and decays stale noise. Recall gained temporal, usefulness, and knowledge-graph legs beside recency, and provenance trust lanes mark and quarantine untrusted content.

v7.5.0

NVIDIA NIM retrieval

Optional NVIDIA NIM embeddings + reranker as an explicit opt-in beside the local default. On LoCoMo, NIM embeddings lift recall@1 33% → 47% and the reranker again to 52%; nothing egresses unless you turn it on, and the per-recall receipt names any remote scorer that saw text.

Full changelog →