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

Explicit Handoffs

For long-running work across devices, Engrm now has an explicit handoff flow:

• create_handoff
  • snapshot the active thread into a syncable handoff message
• refresh_handoff
  • refresh the rolling live handoff draft for the current session
• recent_handoffs
  • list the latest saved handoffs
• load_handoff
  • reopen a saved handoff as a clear resume point in a new session

Recent handoffs now carry:

• source machine
• freshness
• current thread / recent outcomes
• optional chat snippets when the session is still thin

Rolling handoff drafts:

• are kept as one updatable syncable draft per session
• refresh during prompt-time and tool-time summary updates
• let another machine resume live work even before you save a deliberate handoff
• are refreshed again before Claude compacts, so the active thread survives context compression better

The local workbench now shows handoff split too:

• saved handoffs
• rolling drafts

activity_feed and session_story now keep that distinction visible too, so a live rolling draft does not masquerade as a deliberate saved handoff.

When Engrm knows your current device, handoff tools also prefer resume points from another machine before showing the newest local handoff again.

This is the deliberate version of multi-device continuity: useful when you want to move from laptop to home machine without waiting for an end-of-session summary.

The separate chat lane is still kept distinct from durable observations, but it can now sync too, so recent user/assistant conversation is recoverable on another machine without polluting the main memory feed.

For long sessions, Engrm now also supports transcript-backed chat hydration:

• refresh_chat_recall
  • reads the Claude transcript for the current session
  • fills gaps in the separate chat lane with transcript-backed messages
  • keeps those rows marked separately from hook-edge chat so recall can prefer the fuller thread

Before Claude compacts, Engrm now also:

• refreshes transcript-backed chat recall for the active session
• refreshes the rolling handoff draft
• then injects the preserved thread into the compacted context

So compaction should reduce prompt-window pressure without making the memory layer act like the conversation never happened.

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
• capture_quality shows whether chat recall is transcript-backed or still hook-only across the workspace
• memory_console gives the quickest project snapshot, including whether continuity is fresh, thin, or cold
• activity_feed shows the merged chronology across prompts, tools, chat, handoffs, observations, and summaries
• recent_sessions helps you pick a session worth opening
• session_story reconstructs one session in detail, including handoffs and chat recall
• 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, including continuity state and hot files
• workspace_memory_index shows coverage across all repos on the machine
• recent_chat / search_chat now report transcript-vs-hook coverage too, so weak OpenClaw recall is easier to diagnose and refresh

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.