Engrm

The only AI memory that syncs across devices and agents.

Cross-device persistent memory for OpenClaw, Claude Code, Codex, and any MCP-compatible agent. Start free with 2 devices.

Get Started • Documentation • Blog

Docs: Architecture • Plugin Spec • Roadmap • Security

Why Engrm?

• Cross-device sync — Fix a bug on your laptop, continue on your desktop. No other memory tool does this.
• Cross-agent compatible — Works with OpenClaw, Claude Code, Codex, Cursor, Windsurf, Cline, Zed
• Free tier — 2 devices, 5,000 observations, full sync. £0 forever.
• Offline-first — Local SQLite + sqlite-vec. <50ms search. Works on a plane.
• Delivery Review — Compare what was promised vs what shipped
• Sentinel — Real-time code audit before changes land
• Team memory — Share insights across your whole team (Team plan)

vs Other Memory Tools

Read the full comparison →

Installation

For OpenClaw Users

# 1. Install the plugin
openclaw plugins install engrm-openclaw-plugin

# 2. Restart OpenClaw
# Quit and reopen, or restart gateway

# 3. Connect Engrm in chat
/engrm connect

# 4. Verify
/engrm status

What works:

• ✅ Session startup memory injection
• ✅ Automatic session capture
• ✅ Cross-device sync (unique to Engrm)
• ✅ /engrm slash commands
• ✅ Sentinel advisory mode (Vibe+ plans)

Blog: Engrm Now Supports OpenClaw →

For Claude Code / Codex

npx engrm init

This auto-configures MCP servers and hooks in ~/.claude.json and ~/.codex/config.toml.

Alternative methods:

# From a provisioning token (shown on engrm.dev after signup)
npx engrm init --token=cmt_your_token

# Self-hosted Candengo Vector
npx engrm init --url=https://vector.internal.company.com

# Manual setup (air-gapped environments)
npx engrm init --manual

For npm users, Engrm runs on Node.js 18+ and does not require Bun to be installed.

How It Works

Background Operation

Engrm works automatically:

• Session start — injects relevant project memory into context
• While you work — captures observations from tool use where the agent exposes that hook surface
• Session end — generates a session digest, syncs to cloud, and turns recent work into a denser project brief

━━━ Engrm Session Summary ━━━

📋 Request: Fix the OAuth redirect validation
🔍 Investigated: redirect_uri handling in auth.py
💡 Learned: scheme + host + port must all match registered URIs
✅ Completed: Stricter redirect_uri validation (auth.py)

🟢 Risk: Low (0.12)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Check Status

npx engrm status

Engrm Status

  User:        david
  Email:       david@example.com
  Device:      macbook-a1b2c3d4
  Plan:        Pro (£9.99/mo)
  Server:      https://engrm.dev
  MCP server:  registered
  Codex MCP:   registered
  Hooks:       registered (6 hooks)
  Codex hooks: registered (2 hooks)

  Observations:    1,247 active
  By type:         change: 412, discovery: 289, bugfix: 187, ...
  Sentinel:        enabled (advisory, 142/200 today)
  Sync:            push 2m ago, pull 5m ago
  Security:        3 findings (1 high, 2 medium)

Architecture

Claude Code session:

 │
 ├─ SessionStart hook ──→ inject relevant memory into context
 │
 ├─ PreToolUse hook ────→ Sentinel audits Edit/Write (optional)
 │
 ├─ PostToolUse hook ───→ extract observations from tool results
 │
 ├─ PreCompact hook ────→ re-inject memory before context compression
 │
 ├─ ElicitationResult ──→ capture MCP form submissions
 │
 └─ Stop hook ──────────→ session digest + sync + summary
 │
 ▼
Local SQLite (FTS5 + sqlite-vec)
 │
 ▼ (sync every 30s)
Candengo Vector (cloud)
 │
 ▼
Available on all your devices + team members

Codex session:

 │
 ├─ SessionStart hook ──→ inject relevant memory into context
 │
 ├─ MCP tools ──────────→ search, save, inspect, message, stats
 │
 └─ Stop hook ──────────→ session digest + sync + summary

Agent Capability Matrix

See AGENT_SUPPORT.md for detailed comparison.

Features

MCP Tools

The MCP server exposes tools that supported agents can call directly:

Public MCP Starter Set

If you are evaluating Engrm as an MCP server, start with this small set first:

• capture_git_worktree
  • save a meaningful local git diff before it disappears into commit history
• capture_repo_scan
  • capture a quick architecture, implementation, or risk scan as reusable memory
• capture_openclaw_content
  • save posted content, research, outcomes, and next actions from OpenClaw work
• tool_memory_index
  • verify which tools are actually producing durable memory and which plugins they exercise
• capture_quality
  • check whether raw chronology is healthy across the workspace before judging memory quality

These are the tools we should be comfortable pointing people to publicly first:

• thin input surface
• local-first execution
• durable memory output instead of raw transcript dumping
• easy local inspection after capture

Thin Tools, Thick Memory

Engrm now has a real thin-tool layer, not just a plugin spec.

Current first-party thin tools:

• capture_git_worktree
  • reads the current repo diff directly
  • reduces it through engrm.git-diff
• capture_repo_scan
  • runs a lightweight repo scan
  • reduces it through engrm.repo-scan
• capture_openclaw_content
  • captures posted/researched/outcome-style OpenClaw work
  • reduces it through engrm.openclaw-content

These tools are intentionally small:

• tiny input surface
• local-first execution
• reduced durable memory output
• visible in Engrm's local inspection tools so we can judge tool value honestly

Local Memory Inspection

For local testing, Engrm now exposes a small inspection set that lets you see what it actually captured before anything syncs upstream.

Recommended flow:

1. capture_status
2. memory_console
3. activity_feed
4. recent_sessions
5. session_story
6. tool_memory_index
7. session_tool_memory
8. project_memory_index
9. workspace_memory_index

What each tool is good for:

• capture_status tells you whether prompt/tool hooks are live on this machine
• memory_console gives the quickest project snapshot
• activity_feed shows the merged chronology across prompts, tools, observations, and summaries
• recent_sessions helps you pick a session worth opening
• session_story reconstructs one session in detail
• tool_memory_index shows which tools and plugins are actually producing durable memory
• session_tool_memory shows which tool calls in one session turned into reusable memory and which did not
• project_memory_index shows typed memory by repo
• workspace_memory_index shows coverage across all repos on the machine

Thin Tool Workflow

The current practical flow for thin tools is:

1. memory_console / project_memory_index
2. tool_memory_index
3. capture_git_worktree or capture_repo_scan
4. session_tool_memory
5. session_story

That lets you:

• see what Engrm already knows
• see which tools/plugins are producing value
• capture the current repo state with a thin tool
• verify whether that tool produced reusable memory

MCP Examples

These are the kinds of prompts Engrm's current MCP slice is designed for:

• "Capture this current git worktree as memory before I switch tasks."
• "Run a lightweight repo scan focused on auth and validation."
• "Show which tools are actually creating durable memory in this repo."
• "Tell me whether raw prompt/tool capture is healthy on this machine."
• "Save this OpenClaw research/posting run as reusable memory."

For concrete example flows and reducer outputs, see MCP_EXAMPLES.md.

Observation Types

Hybrid Search

Local FTS5 + sqlite-vec (all-MiniLM-L6-v2, 384 dims) combined with Candengo Vector's BGE-M3 semantic search. Results merged via Reciprocal Rank Fusion.

Sentinel

LLM-powered review of every Edit/Write before it executes. Catches security issues, anti-patterns, and drift from team decisions.

⚠️ Sentinel: SQL query uses string concatenation instead of parameterized query
   Rule: sql-injection
   (Advisory mode — change allowed)

Built-in rule packs: security, auth, api, react, database.

npx engrm sentinel init-rules  # Install all rule packs
npx engrm sentinel rules        # List available packs

Knowledge Packs

Pre-loaded knowledge for your tech stack. Detected automatically on session start.

Available: typescript-patterns, nextjs-patterns, node-security, python-django, react-gotchas, api-best-practices, web-security

npx engrm install-pack typescript-patterns

Secret Scrubbing

Multi-layer regex scanning for API keys, passwords, tokens, and credentials. Sensitive content is redacted before storage and sync. Custom patterns configurable in ~/.engrm/settings.json.

Retention & Aging

Observations age gracefully: active (30 days, full weight) → aging (0.7x search weight) → archived (compacted into digests) → purged (after 12 months). Pinned observations never age.

Pricing

Free tier stays free forever. No bait-and-switch.

Start with 2 devices and 5,000 observations. Upgrade when you need more.

Sign up at engrm.dev.

Self-Hosted

Point Engrm at your own Candengo Vector instance:

npx engrm init --url=https://vector.internal.company.com --token=cmt_...

Candengo Vector provides the backend: BGE-M3 hybrid search, multi-tenant namespaces, and team sync. See the Candengo docs for deployment.

Configuration

~/.engrm/settings.json

Created by engrm init. Contains API credentials, sync settings, search preferences, secret scrubbing patterns, and Sentinel configuration.

.engrm-project.json

Place in your project root to override project identity for non-git projects:

{
  "project_id": "internal/design-system",
  "name": "Design System"
}

Agent Auto-Registration

Engrm auto-registers in:

• ~/.claude.json — MCP server (engrm)
• ~/.claude/settings.json — 6 lifecycle hooks
• ~/.codex/config.toml — MCP server (engrm) + codex_hooks feature flag
• ~/.codex/hooks.json — SessionStart and Stop hooks

Technical Stack

• Runtime: TypeScript, runs on Bun (dev) or Node.js 18+ (npm)
• Local storage: SQLite via better-sqlite3, FTS5 full-text search, sqlite-vec for embeddings
• Embeddings: all-MiniLM-L6-v2 via @xenova/transformers (384 dims, ~23MB)
• Remote backend: Candengo Vector (BGE-M3, Qdrant, hybrid dense+sparse search)
• MCP: @modelcontextprotocol/sdk (stdio transport)
• AI extraction: @anthropic-ai/claude-agent-sdk (optional, for richer observations)

License

FSL-1.1-ALv2 (Functional Source License) — part of the Fair Source movement.

• ✅ Free to use, modify, and self-host
• ❌ You cannot offer this as a competing hosted service
• ✅ Each version converts to Apache 2.0 after 2 years
• ⚠️ Sentinel is a separate proprietary product

See LICENSE for full terms.

Documentation

• Architecture: ARCHITECTURE.md
• Contributing: CONTRIBUTING.md
• Security: SECURITY.md
• Roadmap: ROADMAP.md

Maintainers: run node scripts/check-public-docs.mjs to verify the repo only contains the approved public docs set at the root.

Resources

• Documentation
• Blog
• Pricing
• Sentinel

Community

• Twitter/X
• GitHub Issues

Found this useful? ⭐ Star this repo to help other developers discover Engrm.

Built by the Engrm team, powered by Candengo Vector.