Cavemem
Cavemem delivers local-first MCP memory and content-addressed compression for coding agents.
If your coding agent repeats itself and the bill proves it, Cavemem's free MIT-licensed local tier is a low-risk experiment. The content-addressed compression is the actual product; a plain SQLite memory store you could build yourself in an afternoon. Go in expecting variance — the vendor's own claude-code benchmark shows 33.2% fewer input tokens across 18 runs, but one case regressed 9.9%, so measure your own workload before rolling it out.
Verified 4d ago · liveness 72/100 · cite: rightaichoice.com/tools/cavemem
- Developers running MCP coding agents who want persistent, cheap recall across sessions
- Teams on Claude Code, Codex or Cursor watching token spend climb on repeated context
- Engineers who need agent memory to stay on local disk, not in a vendor cloud
- Small teams already using Caveman's agent or middleware who want memory in the same stack
- Teams needing one shared agent memory synced across many machines on the free local install
- Non-developers who want a point-and-click memory product out of the box
- Projects with no MCP-compatible agent, where there is nothing to attach memory to
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Cavemem if you need one shared agent memory synced across several machines today — Caveman Cloud is still in private development, and the local store keeps memory on a single machine's disk.
Your model-provider inference bill is untouched by the free local tools — Cavemem removes context, it does not pay Anthropic, OpenAI, or Google for you
Cheapest end of the memory-tool market by a wide margin: the local Skill, Proxy, Middleware, Browse, and Cavemem layer carry no Caveman subscription fee and no account, against Mem0's and Zep's hosted plans which charge per-seat or per-request. Router and Cloud sit above it in private development, priced per workload via a call with the founder. For a solo developer or small team, free-local-plus-your-own-keys undercuts managed memory vendors; larger teams needing shared traces, budgets, and
In short
Cavemem — Cavemem delivers local-first MCP memory and content-addressed compression for coding agents. Best for Developers running MCP coding agents who want persistent, cheap recall across sessions, Teams on Claude Code, Codex or Cursor watching token spend climb on repeated context, Engineers who need agent memory to stay on local disk, not in a vendor cloud. Free to start; paid plans from $300/mo.
What's new in Cavemem
Checked 4 days agoAcross the latest 10 updates: 3 feature updates, 3 community discussions and 4 news mentions.
Caveman Live Model routing now available in Claude Code
Model routing is live in Claude Code. Same agent, routes each subagent to the appropriate model.
Benchmarking Sonnet 5.5: less thinking for the same answers
Field report on a 48-task suite: at equal effort, Sonnet 5.5 solved at least as many tasks and usually spent less.
Caveman, RTK, Headroom, and context-mode compared
Compares what each tool shrinks, how omitted content is recovered, telemetry defaults, and what the published numbers measure.
21 adapters for the agent you already built
Adds eight TypeScript and thirteen Python adapters, plus recoverable tool-result compression inside existing agents.
How to cut Claude Code costs without making it dumber
Seven levers to reduce Claude Code costs, the measured number behind each, what breaks them, and when they lose money.
How Caveman works with LiteLLM
Covers per-call api_base, fleet-wide config.yaml, running Claude Code through both, and a routing callback that never touches inference.
Headroom vs Caveman for prompt compression, measured
Same six tasks, 54 runs, exact-answer check on each: 33.2 percent against 6.7, with the rows where each lost.
What Claude Code actually bills you for
Breaks down the four counters Claude Code bills, one ten times cheaper than the others, and the prefix that decides which you pay.
Your agent pays before it works
One real agent loaded 224,655 characters of tool schemas before its first action, most from plugins it might never call.
The 47 tokens your agent should never summarize
Compaction can preserve a job while deleting its rules. One benchmark found a 47-token buffer prevented the failure.
What people actually say about Cavemem — is it worth it?
We scanned public community sources for Cavemem on Aug 13, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
Viability Score
How well maintained and how widely used is Cavemem? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Persistent memory for coding agents over the Model Context Protocol
- Local SQLite storage with FTS5 full-text and vector indexing
- Content-addressed compression of memory entries into recoverable handles
- Recoverable originals fetched back byte-for-byte when the agent asks
- MCP tools for storing, querying and forgetting memories
- Local-first operation with no cloud dependency
- Token-efficient recall that avoids re-sending past context
- Works with Claude Code, Codex, Cursor, OpenCode, Gemini CLI and 30+ agents
- Install in one command: npm install -g cavemem
- MIT-licensed open source, no account or credit card
- Offload a large CLAUDE.md into recall instead of every prompt
- Headless CLI and MCP access to Caveman Cloud
- TypeScript and Python middleware packages with 21 adapters
- Live model routing available in Claude Code, choosing a model per subagent
- Compression of logs, JSON, diffs and documents before the model call
About Cavemem
Cavemem is the memory layer inside the Caveman toolchain — a local-first persistent store built for coding agents on the Model Context Protocol. Memories live in a local SQLite database with FTS5 full-text and vector indexing, so an agent recalls earlier work rather than re-sending the same context every invocation. Install takes one command (npm install -g cavemem), after which the MCP server exposes store, query and forget tools to any compatible client: Claude Code, Codex, Cursor and the 30+ agents Caveman's skill installs into. The compression angle is where the money is saved. Memories are kept as content-addressed handles, so an agent gets a short recoverable pointer instead of a wall of pasted text, and the original is pulled back byte-for-byte when it genuinely matters. It sits alongside the rest of the Caveman stack: the free open-source agent that trims tool results before they hit the model, the TypeScript and Python middleware for agents you build (21 adapters as of the September releases), and Caveman Cloud. That local wrap is free, MIT-licensed, and needs no account — your model-provider inference charges still apply. Caveman Cloud, the paid side, adds LLM observability, eval scoring, Autopilot and Ask, plus routing decisions; the free Cloud tier covers one person with 100,000 events, 600 agent minutes and 25,000 routing decisions a month. The audience is developers and small teams running MCP agents who watch token spend climb on repeated context. Two groups should look elsewhere for now: non-developers who want a point-and-click memory dashboard, and projects without any MCP-compatible agent to attach memory to. Against Mem0 or Zep, Cavemem trades managed convenience for local data ownership and a published paired benchmark — 33.2% fewer input tokens across 18 Claude Code runs, with one case regressing 9.9%.
Behind the Verdict
Agent memory is a crowded shelf, and most entries sell you a hosted database plus a dashboard. Cavemem takes the opposite bet: keep everything on local disk, hand the model short content-addressed pointers, and pull the exact original back only when the task needs it. We'd reach for this when the agent loop keeps re-reading the same CLAUDE.md, test logs and diffs turn after turn. Offloading a bloated CLAUDE.md into recall is the fastest payback we've seen from the free tier. Pick it if you're already running MCP agents in Claude Code, Codex or Cursor and you want the data on your own machine. One npm command, no account, no card. The compression numbers are vendor-published but paired, and the company published the losing rows too — 33.2% fewer input tokens across 18 Claude Code runs, one case 9.9% worse. Elasticsearch Labs, separately, measured 63.6% fewer output tokens across eight live MCP scenarios, and the blog walks through where each tool in the comparison lost. Pass if you need one memory synced across many machines or a hosted dashboard. The local wrap is genuinely local, and shared traces live on the paid Cloud side. Pass too if you're not a developer, or if there's no MCP-compatible agent in your stack — there's nothing to attach memory to. The closest comparison is Mem0 or Zep. Both give you managed convenience and cross-machine sharing; Cavemem gives you ownership and a compression trick they don't ship. If your team already runs Caveman's middleware or SDK, the memory layer slots into the same namespace-and-scope pattern with no new provider keys. Caveats from real use. Content-addressed recall only pays off when an agent actually asks for the original — if it never does, you bought a fancier log file. The routing and Cloud observability features are
Researching Cavemem? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Cavemem actually fits — and what changes day-one when you adopt it.
Install cavemem with npm install -g cavemem, point the MCP server at the project, and let the agent store and query decisions across sessions instead of re-pasting the same file context every run.
Outcome: Recall happens over MCP from a local SQLite store, so repeat context stops being re-sent; run caveman learn to rank what is actually eating the budget before and after.
Move a large instruction file out of every prompt and into recall, so the agent fetches only the section a question needs rather than the whole file each turn.
Outcome: Fewer tokens per invocation with the original text still recoverable by handle when the agent needs the exact wording.
Wire the MCP store, query, and forget tools into a custom agent alongside the TypeScript or Python middleware, and measure recall and compression on real sessions before considering any hosted option.
Outcome: A concrete token-per-task number from your own workload, with the option to revisit Cloud or Router later if team-wide visibility becomes the next problem.
Use Cases
- Store and recall agent context across sessions so the same data is not re-sent every run
- Reduce token consumption by keeping memory entries as content-addressed handles with recoverable originals
- Offload a heavy CLAUDE.md out of every prompt and into recall on demand
- Give Claude Code or Codex persistent memory of past interactions through the MCP server
- Build custom MCP agents that need long-term recall without a hosted memory vendor
- Rank what is eating your agent's budget locally before committing to a cloud provider
- Evaluate memory retrieval and compression patterns on your own workload first
Models Under the Hood
as of 2026-10-16
Limitations
- Cavemem itself is free and open source, so you still pay your model provider for inference and cover your own infrastructure; savings depend on your workload.
- Caveman Cloud is a managed LLM gateway with a Free tier for one person and a Team tier at $300/month including $300 of usage, with allowances (events, agent minutes, routing decisions, Caveman AI spend) and standard rates past them.
- Verified savings are labeled (measured, inferred, tested, verified) rather than guaranteed.
as of 2026-10-04
Verification history
We have re-verified Cavemem 10 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 10 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Cavemem tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free (Cloud)
$0/mo
Team (Cloud)
$300/mo
Enterprise (Cloud in your VPC)
Custom / year
Open Source (agent + SDK, local)
$0
Where the pricing makes sense
The company stage and team size where Cavemem's pricing actually pencils out — and where peers do it cheaper.
Cheapest end of the memory-tool market by a wide margin: the local Skill, Proxy, Middleware, Browse, and Cavemem layer carry no Caveman subscription fee and no account, against Mem0's and Zep's hosted plans which charge per-seat or per-request. Router and Cloud sit above it in private development, priced per workload via a call with the founder. For a solo developer or small team, free-local-plus-your-own-keys undercuts managed memory vendors; larger teams needing shared traces, budgets, and
Setup time & first value
How long it actually takes to get something useful out of Cavemem — broken out by persona, not the marketing-page minute.
Solo developer on Claude Code: one command (npm install -g cavemem) plus an MCP client entry — realistic first recall in about 10 minutes, matching Caveman's stated five-minute quickstart for the local tools. Small team standardising on the Caveman stack: roughly half a day to add Proxy, Skill, and memory together and establish a before/after token baseline. Enterprise evaluating Cloud or Router:
Switching to or from Cavemem
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From pasting context manually each session: install cavemem, store the recurring files as memories, and let the agent query them instead of re-pasting
- →From a hand-rolled SQLite scratchpad: keep the local-store model and add FTS5 plus vector recall and content-addressed compression for free
- →From a hosted memory vendor: export entries, write them into the local store via the MCP store tool, and keep originals recoverable by handle
- →From a large CLAUDE.md instruction file: offload it into recall so only the relevant section enters the prompt
- ↗To a managed memory service such as Mem0 or Zep: export local entries and re-index them in the hosted store when cross-machine sync becomes a hard requirement
- ↗To rolling your own SQLite scratchpad: memory is already a local SQLite file, so you can read it directly and drop the MCP layer
- ↗To Caveman Cloud: headless CLI and MCP access are already exposed, so the local memory workflow can move to the hosted platform when it leaves private development
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Cavemem”, and we withheld 6: 6 could not be judged, because “Cavemem” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Cavemem.
Official links
Featured Head-to-Head Comparisons
Cavemem vs Spider Cloud
Choose Spider Cloud if your AI agent needs live web data for RAG or scraping — its Rust-powered engine and 1,000+ ready-made scrapers make data ingestion cheap and fast. Choose Cavemem if you build coding agents and want to slash token costs by retaining context locally via MCP. They solve different problems: one pulls external data, the other remembers internal conversation history.
Cavemem vs Voyage Ai
Choose Voyage AI if you need high-accuracy embedding models and rerankers for enterprise RAG pipelines, especially for finance or legal documents, and have a budget for a contact-sales pricing model. Choose Cavemem if you are a developer building agentic coding assistants with MCP and want a token-efficient, local-first persistent memory layer to reduce repeated context – it's free to use locally. These tools serve fundamentally different needs: one is for retrieval quality, the other for agent memory efficiency.
Cavemem vs Temporal Ai
Choose Temporal AI if you need to build fault-tolerant, long-running orchestration for AI agents or microservices – it survives crashes and retries automatically. Choose Cavemem if you're a developer looking to reduce token costs when repeating context to coding agents like Claude Code, and you prefer a local-first, MCP-native memory solution. For a team building reliable production agent workflows, Temporal is the proven heavyweight; for individual developers optimizing agent memory, Cavemem is lean and token-efficient.
Popular in Agent Memory & Runtimes
Frequently Asked Questions
Used Cavemem? Help shape our editorial sentiment research.