Key Takeaways
- cmem.ai Pro enhances Claude-Mem by providing off-plan observation generation, bi-directional cloud sync, and a private MCP link.
- This service is distinct from Anthropic’s Claude Pro and functions as a paid layer on the free, open-source version.
- The main features include handling observer tokens and offering a sync mechanism without a daemon.
- Users can cancel anytime, but must check changing prices before subscribing, as they fluctuate often.
- cmem.ai Pro focuses on multi-machine workflows and addresses token burn issues effectively.
Estimated reading time: 12 minutes
This is a follow-up to my post on Claude-Mem. If you’ve been living inside Claude Code (or Cursor, or any of the other agentic IDEs) for more than a couple of weeks, you’ve probably hit the same wall I did: the agent forgets. Session ends, context evaporates, and you’re back to re-explaining the architecture, the dead ends, and the decisions you already made. That’s the problem thedotmack’s claude-mem set out to solve. The open-source engine has been climbing the GitHub charts hard — roughly 90,000 stars and 7,800 forks as of early August 2026 — and now there’s a paid layer called cmem.ai Pro sitting on top of it.
This is not Anthropic’s Claude Pro subscription. That distinction matters more than it should, because Google still serves a lot of “is Claude Pro worth it” content that has nothing to do with this project. cmem.ai Pro is a thin paid overlay on an Apache-2.0 local memory engine. It routes observation generation off your own plan, adds bi-directional cloud sync, and gives you one private MCP endpoint that works across every machine and client you own. The rest of the interesting stuff — the skills, the File Read Gate, Smart Explore, Knowledge Agents, Dreaming — is already free.
I’ve been digging through the docs, the GitHub issues, the installer, and the public complaint threads so you don’t have to. Here’s the full picture as of v13.14.0.
What cmem.ai Pro Actually Is (and Isn’t)
Pro is not a separate product. It is not a hosted fork. When you select Pro in the installer, four settings get written:
CLAUDE_MEM_PROVIDER: openrouterCLAUDE_MEM_OPENROUTER_BASE_URL: https://cmem.ai/api/inference/v1CLAUDE_MEM_OPENROUTER_MODEL: cmem-observerCLAUDE_MEM_OPENROUTER_API_KEY: cm_pro_<hex>
That’s it. No new provider code shipped with the feature. The engine itself — thedotmack/claude-mem — remains fully open source under Apache-2.0. Cancel Pro and everything local keeps working. cmem.ai’s own billing copy is explicit about that.
Three release branches exist (community-edge → core-dev → main). Only main is published to npm. The project has been shipping multiple releases per week; v13.14.0 landed right around the time this research was locked. Treat every version-specific claim as point-in-time.
If you already installed the free plugin, you already have the core. Pro is the inference endpoint plus the sync hub bolted on top.
The Full Pro Feature Inventory
There are exactly four Pro-gated capabilities. Everything else you see on the marketing pages is free.
| Capability | Status | Notes |
|---|---|---|
| cmem-observer model (off-plan observation generation) | Live, Pro-only | The economic headline |
| Real-time bi-directional cloud sync | Live (beta), Pro-only | Two-lane, worker-native |
| Private MCP link on every machine | Live, Pro-only | One endpoint, any MCP client |
| CMEM Cloud beta access | Beta, included | Hosted Server is still rough |
The marketing line “up to 3x more building from the same plan” is a consequence of the observer model, not a fifth feature. Integrations (Claude Code, Cursor, Windsurf, Codex CLI, Gemini CLI, VS Code, Telegram, Discord, etc.) are properties of the open-source engine. None of them are Pro-gated.
Roadmap items like RAD (the open standard for Dreaming), Adaptive Index Size, and full team collaboration are not Pro features either — they are unreleased.
The Observer Model and Off-Plan Tokens
This is the only feature with a hard economic argument.
On the free tier, every observation is generated through whatever provider credentials you gave the engine — usually your Anthropic plan via the Claude Agent SDK, or an OpenRouter/Gemini key. Because the observer sees file contents on every PostToolUse and runs unbounded, the cost is invisible and can explode. GitHub issue #2643 documents the extreme cases: one user burned 649 million tokens across roughly 530 observer sessions (about $580 at Sonnet 4.6 pricing). Another hit 1.28 billion tokens. The root cause was full pre/post file contents instead of diffs plus an unbounded observer conversation that produced quadratic cache-read growth. It was closed as fixed in late May 2026, though a late-July comment on the same issue reported a regression on the OpenAI-compatible path.
Pro routes that traffic to cmem.ai’s own cmem-observer endpoint. Observation tokens never touch your Claude plan. The installer now ranks providers by labeled cost and puts your Anthropic plan last at roughly $8.91 per 1,000 observations. Pro itself is labeled $0 per 1k with the $30 monthly fee covering it.
Pro includes 75 million tokens per month. Higher usage tiers exist (Heavy, Power, Team) but the numbers and prices have shifted across pages, so treat them as fluid and email support if you blow past the included allowance. Response window is stated as 24–48 hours.
If you have ever watched your plan limits disappear for reasons you couldn’t immediately explain, this is the feature that addresses the actual pain.
Cloud Sync: How the Two-Lane Sync Actually Works
This is the most technically interesting piece and the one most likely to earn its own deep-dive later.
There is no daemon. The worker that already records observations also handles sync. Each account gets a per-user sync hub (Cloudflare Durable Object) that exposes an ordered log.
Two lanes:
- Durable HTTP push/pull is the source of truth, cursor-based.
- Optional WebSocket is purely advisory — it only makes the next pull happen sooner. The socket can drop with zero data loss. The hub can force poll-only mode.
Push side: the database itself is the queue via a synced_at column (NULL = unsynced). Writes are debounced ~1.5 s after the last write (250 ms when the socket is connected), batched up to 500 ops or 4 million encoded bytes, individual bodies capped at 256 kB, 30-second request timeout, capped exponential backoff. Pushes are idempotent.
Pull side: session start pulls immediately (bounded to 1.5 s) before context injection. Steady state polls every 30 s while active, every 5 min idle, suspended after an hour of inactivity. Pulled rows keep original timestamps, carry the origin device, and are stamped so they cannot echo back.
What replicates: observations, session summaries, and user prompts (each field clamped to 200 KB). Mutations that propagate include session title changes, prompt-to-session repairs, and project remaps.
Device hard limit: 64 distinct device IDs per account. A 65th device receives 409 device_limit_exceeded. Marketing pages never state the number; only the technical docs do.
The privacy line is worth quoting verbatim from the Cloud Sync docs:
cloud sync uploads your observation narratives and your full prompt text to the sync hub under your cmem.ai account. Don’t enable it if that content must stay on your machine.
Sync is off by default. It activates only when the token, user ID, and hub URL are all non-empty. A /cloud-sync skill inside Claude Code walks the setup, writes settings at mode 0600, restarts the worker, and verifies reachability. GET /api/sync/status on the worker port returns a useful debug payload even on unconfigured installs.
Setup friction is real but mostly documentation-related (naming inconsistency between CLAUDE_MEM_CLOUD_SYNC_URL and the actual _HUB_URL key, plus a warning not to use the application API URL). The release history around the initial two-lane launch was visibly turbulent — multiple same-day fixes for restart storms and merge sweeps.
The Private MCP Link: One Endpoint, Every Client
cmem.ai frames it simply: one private MCP endpoint, scoped to your account, never shared, revocable or regenerable in one click, usable from any MCP client. That shape is genuinely differentiated. Most competitors still expect you to stand up or configure a server per client.
Honesty note: Codex CLI currently gets read-only access over MCP. Auto-capture via hooks is still Claude-Code-centric. Non-Claude-Code clients generally get recall without the automatic observation pipeline. That is the kind of detail that keeps a review independent.
Separately, the Hosted Server (beta) is a different animal — Postgres-backed /v1 HTTP service with a BullMQ worker, team/project scoping, read-only MCP surface, and right-to-erasure support. Its own docs are blunt: early, moving fast, no polished dashboard, no self-serve signup yet, first-key bootstrap is rough. Treat it as a future Team-tier building block, not a current selling point.
What You Already Get Free
This is the section most vendor pages blur. Everything local is free and Apache-2.0. Being explicit about it is the single most useful correction a review can make.
Worth naming:
- 11 bundled skills (search memory, build brains, smart-explore, deep-learn a repo, research/write plans, orchestrate with subagents, etc.)
- Progressive-disclosure search across four MCP tools and three layers (50–100 tokens for index hits, up to 500–1,000 for full observations)
- File Read Gate — PreToolUse hook that blocks full reads on previously observed files and injects a short timeline instead (worked example in the docs: 18,000 → 970 tokens)
- Smart Explore — tree-sitter AST tools with measured 10–20× token reductions versus naive Glob/Grep/Read on the project’s own source
- Knowledge Agents — build/prime/query a corpus with a 1 M-token window, answers sourced to session IDs
- Dreaming — live observation generation with before/after threading
- Private tags that strip content at the hook layer before storage
- Modes, 28 languages, folder context files, export/import scripts
Two caveats worth a sentence each: telemetry is PostHog-based, anonymous, and on by default (DO_NOT_TRACK is respected). And npm install -g claude-mem only installs the SDK — the real install path is npx claude-mem install or the plugin marketplace command.
New in the v13.13 series: a ninth observation type called “sensitive” that covers internal URLs, unreleased plans, business metrics, and client names, with optional Telegram notification.
Pricing, Tiers, and the Verdict
Current headline number on the /pro and /pricing pages is $30 per month for CMEM Pro (75 M tokens included, observer + cloud sync + private MCP link + Cloud beta). Higher usage tiers and a Team seat price appear, but the exact numbers disagree across pages (homepage still says $20/month for CMEM Cloud; some vs pages still show $199/year; Team seat price has shown both $249 and $333). No formal refund or proration policy is published. Cancel anytime from Billing; local engine keeps working.
Publish $30/mo as the working number and always check the live pages before you buy. Price experiments are clearly still happening.
Competitor anchors for context only:
- mem0: free → $19 → $79 → $249
- Zep/Graphiti: free → $125 → $375
- Basic Memory: free local + $15 cloud
- Letta: free → $20
The competitor that actually matters is Anthropic’s own free memory. Claude Code ships CLAUDE.md plus Auto Memory (MEMORY.md). Consumer Claude chat memory has been free across tiers since March 2026. The honest counter is scope: Anthropic’s memory is locked to its own surfaces. It does not sync across Claude Code, Cursor, Codex CLI, and the rest. The two systems are complementary for most people, not direct substitutes.
Where cmem.ai genuinely differentiates:
- Hook-level automatic capture (the agent does not have to decide to call a memory tool)
- Off-plan observer tokens
- One private MCP link that reaches every client
- Worker-native sync with no daemon
- Multi-IDE reach
- A capable free local tier that is actually free
Weaker on graph memory (Zep and mem0 both do this), team/enterprise compliance, and polished multi-user UX (Hosted Server is still early).
Public sentiment is mixed in useful ways. The token-burn reports are real and self-documented. A March 2026 dev.to piece called the implementation “Great Idea, Poor Implementation.” An April local-API exposure finding and an unpinned chroma-mcp supply-chain discussion both exist. Positive mentions appear (Augment Code recommended it), but the critical material is stronger and more actionable than the testimonials on the vendor site.
Segmented verdict:
- Single-machine solo developer on a Claude Max plan — hard to justify $30 unless you are actively watching observer burn eat your limits. Free engine + native CLAUDE.md covers a lot.
- Multi-machine workflow (laptop + desktop + VPS) — this is the buyer. Cloud sync plus one MCP link is the entire pitch. DIY symlink/iCloud/git hacks are unmaintained and incomplete.
- Anyone who has already been burned by unbounded observation tokens — the off-plan observer is a direct fix. Do the arithmetic against the installer’s $8.91/1k figure.
- Teams — the seat pricing and Hosted Server exist, but the “no polished dashboard, no self-serve signup” warning means wait until the Team experience is actually usable.
FAQ
Is claude-mem Pro worth it?
Depends on your workflow. Multi-machine or high observer burn: yes. Single machine on a generous plan: usually not yet. This is not Anthropic’s Claude Pro.
What does cmem.ai Pro add over the free plugin?
Four things: cmem-observer (off-plan tokens), bi-directional cloud sync, private MCP link, and CMEM Cloud beta access. Everything else is free.
Does it work with Cursor?
Yes. Cursor is a first-class integration on the free engine; the private MCP link makes recall available from Cursor the same way it does from Claude Code.
Does it work with Codex CLI?
Read-only over MCP today. Hook-driven capture is still primarily Claude-Code oriented.
Is my data private?
Local-first by default. <private> tags strip content before storage. Telemetry is on by default but anonymous and opt-out. Cloud sync explicitly uploads full prompt text and observation narratives once enabled — leave it off if that is unacceptable.
Can I cancel anytime?
Yes. No published refund or proration policy.
How many devices does it support?
64 distinct device IDs per account (hard limit in the sync hub). Marketing never states the number.
Does it use my Claude plan tokens?
Free tier: yes. Pro: no — observations run on cmem-observer.
What is RAD?
Retrieval-Augmented Dreaming, an announced but unshipped open standard. Dreaming itself already ships in the free engine.
How does cloud sync work — is there a daemon?
No daemon. The worker syncs on write using a synced_at queue column, durable HTTP as source of truth, and an optional advisory WebSocket.
Does it slow down my agent?
Observation generation is designed to run out-of-band. Real-world performance complaints exist (see the March 2026 implementation critique); test it on your own workload.
How is this different from Claude’s built-in memory?
Scope and reach. Anthropic’s memory is free and solid inside Claude surfaces. cmem.ai is cross-tool, automatic at the hook layer, and optionally multi-device.
If you already run the free plugin and are happy on one machine, keep running it. If you bounce between laptop, desktop, and a remote box — or if observation generation has already bitten your plan limits — Pro is one of the few paid memory layers that is actually solving a problem the free tools leave open. Just check the live pricing page before you pull the trigger; the numbers are still moving.
Full walkthrough of the free engine, the five lifecycle hooks, and the February 2026 community security audit are in earlier posts. Cloud Sync architecture and the observer-token math both deserve (and will get) their own deep-dives.
