Roampal

Roampal

A local-first AI memory layer for coding tools that scores memories by whether they actually worked.

74/100Safe BetFree planFreemium

If you use Claude Code or OpenCode heavily across multi-session projects, Roampal is worth a look because it evaluates memories by outcome rather than similarity. The distinctive pieces are TagCascade with cross-encoder reranking, the Wilson-score outcome feedback loop, and the three-tier lifecycle that ages out unproven memories. The poison-resilience result — 2.6–4.2 points lost against 1,135 adversarial memories with spoofed trust signals — is the strongest thing in its published data. Compare it to cloud memory layers such as Mem0 or Zep, which are easier to set up but don't score against observed outcomes, and to plain vector RAG you could wire up yourself.

Verified 16d ago · liveness 74/100 · cite: rightaichoice.com/tools/roampal

Best for
  • Developers running Claude Code on complex multi-session projects
  • Developers using OpenCode or similar coding agents
  • Privacy-focused developers who want memory stored locally with no telemetry
  • Power users who want to steer their AI assistant's context with feedback
Not ideal for
  • Non-technical users who don't work in a terminal or coding agent
  • People wanting memory for general chatbots rather than coding tools
  • Those who need cloud sync or memory shared across multiple devices
Visit Website

AdvancedFor Claude Code or OpenCode users: a pip install roampal followed by roampal init auto-detects your tools, or you target one explicitly with --claude-code or --opencode. First useful context arrives once a few exchanges have been summarized, tagged, and scored, so expect the first session to be largely untested memories. For the local-model path via the desktop app, add the time to get Ollama orDesktop · CLINo public APIVerified 16d ago
Pricing
Free plan
FreemiumFree tier2 plans4 hidden costs
Learning curve
Advanced
For Claude Code or OpenCode users: a pip install roampal followed by roampal init auto-detects your tools, or you target one explicitly with --claude-code or --opencode. First useful context arrives once a few exchanges have been summarized, tagged, and scored, so expect the first session to be largely untested memories. For the local-model path via the desktop app, add the time to get Ollama or
Runs on
DesktopCLI
No public API · 5 integrations
Who it's for
Solo developer deep in a multi-week Claude Code projectOpenCode user testing a fix that may or may not workPrivacy-focused developer running local models
Live sentiment
Is Roampal actually worth it?

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
Run a free scan

3 free scans · no card needed

Skip it if

Skip Roampal if you work in a coding tool other than Claude Code or OpenCode, need memory shared across multiple devices, or want assistant memory for something other than code.

The 30-second take
Biggest gripe

Running the retrieval pipeline means paying the token cost of a sidecar LLM summarizing, tagging, and fact-extracting every exchange, which compounds across long sessions.

Price reality

Roampal's Core tier is free and open source (Apache 2.0) and covers Claude Code and OpenCode with local storage, which puts the entry point below cloud memory layers such as Mem0 or Zep that bill monthly for hosted memory. The desktop app is a one-time purchase on Gumroad and is where Ollama/LM Studio local inference and the MCP tools live. For a solo developer already running a local model, the effective cost is compute rather than subscription; the trade is that you give up the hosted sync

In short

Roampal — A local-first AI memory layer for coding tools that scores memories by whether they actually worked. Best for Developers running Claude Code on complex multi-session projects, Developers using OpenCode or similar coding agents, Privacy-focused developers who want memory stored locally with no telemetry. Free to use.

What people actually say about Roampal — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

11 mentions across 2 sources (Hacker News, GitHub) · researched Jul 5, 2026.

63% positive37% critical

Average across the 2 sources that answered — each source counts once, not each post.

Recurring strengths
  • +Local-first, no cloud dependency — all data stays on your machine.
  • +Outcome-based scoring beats pure embedding similarity (10% to 60% gain).
  • +Poison-resilient against semantic match and spoofed trust.
  • +Automatic memory lifecycle: working → history → patterns tiers.
  • +Two-lane retrieval with summaries and facts per turn.
Recurring frustrations
  • −Very early stage — only 121 GitHub stars, community is tiny.
  • −Accuracy claims are self-reported, no third-party validation.
  • −Setup requires local LLM for automatic summarization features.
  • −Some users found the blog install pitch too pushy.
  • −No official integrations beyond Claude Code and OpenCode yet.
Patterns worth knowing
Outcome-based scoring as a novel RAG improvement
Seen on Hacker News
Low adoption and early-stage concerns
Seen on Hacker News
Need for independent benchmarks
Seen on Hacker News
Learning curve
intermediateProductive in ~A few hours
Hidden costs people mention
  • • Requires a local LLM (Ollama/LM Studio) for automatic summarization — may need hardware or setup.

Viability Score

74/100
Safe Bet

How well maintained and how widely used is Roampal? 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

Recent activity
not measured
Traction
97
Site health
95
User sentiment
63
What the vendor publishes
40

Last calculated: October 2026

How we score →

Key Features

  • Outcome-based memory scoring (Wilson score, usage count, worked/failed/partial)
  • Outcome detection from natural language phrasing
  • Score deltas: worked +0.2, failed −0.3, partial +0.05
  • Two-lane retrieval: 4 summaries + 4 atomic facts per turn
  • TagCascade tag-first retrieval with tag-overlap tier sorting
  • Cross-encoder reranking of retrieved candidates
  • ChromaDB-backed vector lookup per matched tag
  • Cosine-distance tiebreak and 40-candidate pool floor with cosine fill
  • Sidecar LLM conversation summarization
  • Atomic fact extraction into standalone memory records
  • Noun tag extraction at store time into a known-tag index
  • Three-tier memory lifecycle: working 24h, history 30d, patterns permanent
  • Demotion of patterns below score threshold
  • Memory bank for identity and preferences outside the tier system
  • Books collection for user-uploaded reference docs

About Roampal

FreemiumAdvancedNo APIDesktop · CLI

Roampal is an open-source (Apache 2.0) memory layer for AI coding tools, currently Claude Code and OpenCode. It targets a specific failure of standard RAG: similarity search hands the model whatever sounds related, but never tells it which memories have actually helped before. Roampal scores each memory by past usefulness using a Wilson score, usage count, and outcome feedback, then injects 4 summaries plus 4 atomic facts per turn through a two-lane retrieval design. A background sidecar LLM summarizes every exchange, extracts atomic facts, and tags nouns at store time; at query time a tag-first cascade called TagCascade narrows candidates before a cross-encoder reranks them. Outcomes are detected from natural language: worked adds 0.2, failed subtracts 0.3, partial adds 0.05. Memories move from working (24h) to history (30d) to patterns (permanent), and a separate memory bank holds identity and preferences outside the tier system. On LoCoMo the vendor reports 76.6% end-to-end accuracy versus 53.0% for raw ingestion, with a non-adversarial ceiling of 85.8%, and only 2.6–4.2 points of loss when 1,135 poisoned memories with spoofed trust signals are injected. Data stays local with no cloud dependency and no telemetry. This is a tool for developers running multi-session coding work in Claude Code or OpenCode, not a general chatbot memory product.

Behind the Verdict

Roampal makes a narrow, defensible bet: the value of a memory is not how similar it sounds to the question, but whether it produced a useful result last time. That framing holds up in the vendor's own benchmark, where Roampal's end-to-end LoCoMo accuracy is 76.6% against 53.0% for raw ingestion, a 23.6-point gap reported at p<0.0001, with a non-adversarial ceiling of 85.8%. The mechanics are specific and inspectable. A sidecar LLM summarizes every exchange into a short record, extracts atomic facts as standalone memories, and tags nouns at store time. At query time TagCascade matches query words against the tag index, runs each matched tag through ChromaDB, counts tag overlap, and sorts candidates by tier — all tags matched first, then one fewer, cosine distance breaking ties — with straight cosine filling the pool if fewer than 40 candidates survive. A cross-encoder then reranks. Two lanes retrieve separately and merge: 4 summaries carry narrative, 4 atomic facts carry specifics. The scoring loop is the part most competitors do not have. Outcomes are detected from language like "that worked" or "that failed", and each result shifts a running score: worked +0.2, failed −0.3, partial +0.05. Score plus usage count drive promotion from working (24h) to history (30d) to patterns (permanent), with demotion when a pattern's score falls below threshold and timer-based expiry for un-promoted working and history memories. The weaknesses are as concrete as the strengths. Retrieval is capped at 4 summaries and 4 facts per turn, so a turn that needs more breadth than that won't get it. Scope is limited to Claude Code and OpenCode, with Ollama or LM Studio support sitting in the separate desktop app that also carries MCP tools. Everything is local in the free Core tier, which is the point, but it also means no cloud sync across machines. Quality of the memory store depends on the sidecar LLM's summarization and fact extraction, so a weak local model will degrade the thing you're trying to improve. And the headline numbers come from the vendor's own LoCoMo harness, not independent replication — treat 85.8% as a vendor-reported ceiling. Where it fits: developers who live in a coding agent across weeks-long projects, who want the assistant to stop re-suggesting approaches that already failed, and who would rather keep memory on disk than in someone's cloud. Where it doesn't: anyone who needs multi-device memory sharing, non-coding assistant memory, or a setup that avoids local model infrastructure entirely.

Researching Roampal? 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 Roampal actually fits — and what changes day-one when you adopt it.

Solo developer deep in a multi-week Claude Code project

You install with pip install roampal and run roampal init --claude-code, then work as normal. The sidecar summarizes each exchange, extracts facts like "user prefers tabs over spaces", and tags nouns. On the next auth bug, TagCascade narrows candidates against your tag index and the cross-encoder reranks, so the context block shows the JWT refresh pattern that fixed the loop last week with

Outcome: You stop re-explaining the same project context and the assistant stops resurfacing approaches that already failed.

OpenCode user testing a fix that may or may not work

You try the suggested fix and say "that worked". Roampal detects the positive outcome, adds 0.2 to the running score, and the usage count rises. Use it successfully twice and the memory is promoted from working (24h) into history (30d); keep helping and it graduates to a permanent pattern. If you say "didn't work", the score drops 0.3 and a pattern below threshold is demoted back down.

Outcome: The memory store converges on the fixes that actually work for you, and unproven ones age out on their timers.

Privacy-focused developer running local models

You use the desktop app with Ollama or LM Studio so the sidecar LLM runs entirely on your machine, and you enable the MCP tools for local agent wiring. Nothing leaves the machine — no cloud dependency, zero telemetry — and you can drop reference docs into Books for durable retrieval alongside your memory bank preferences.

Outcome: You get persistent, outcome-scored memory without sending your codebase or conversation history to a hosted service.

Use Cases

  • Reuse fixes that already worked for recurring bugs instead of re-deriving them each session
  • Keep coding preferences like tabs over spaces remembered across sessions
  • Retrieve project context from prior sessions without re-explaining the codebase
  • Track which approaches worked and which failed across hundreds of interactions
  • Build a persistent record of known issues and fixes for your repo
  • Feed back "that worked" to promote a solution into permanent pattern memory
  • Run memory fully locally via Ollama or LM Studio with the desktop app
  • Upload reference docs into the Books collection for durable retrieval

Models Under the Hood

Claude CodeOllamaLM Studio

as of 2026-09-24

Limitations

  • Scope is deliberately narrow: Claude Code and OpenCode are the supported tools, with Ollama and LM Studio support arriving through the separate desktop app that also carries the MCP tools.
  • Retrieval is capped at 4 summaries plus 4 atomic facts per turn, which bounds how much context can surface at once.
  • In the free Core tier everything is stored locally, so there is no cloud sync or multi-device sharing.
  • Memory quality rests on the sidecar LLM that summarizes exchanges, extracts atomic facts, and tags nouns — a weak or small local model will weaken retrieval.
  • Score changes are small by design (worked +0.2, failed −0.3, partial +0.05), so trust in a memory builds over repeated use rather than instantly.
  • The headline benchmark numbers, including 85.8% non-adversarial accuracy and the 2.6–4.2 point degradation under poisoned memories, come from the vendor's own LoCoMo harness rather than independent replication.

as of 2026-09-22

Verification history

We have re-verified Roampal 8 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.

  1. — re-checked, vendor evidence unchanged
  2. — re-checked, vendor evidence unchanged
  3. — re-checked, vendor evidence unchanged
  4. — re-checked, vendor evidence unchanged
  5. — re-checked, vendor evidence unchanged
  6. — 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 8 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.

Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Roampal tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Core

$0/mo

Ideal for

Solo developers using Claude Code or OpenCode who want local, outcome-scored memory with no subscription and are fine keeping everything on one machine.

What this tier adds

Starting tier and free entry point: open source under Apache 2.0, works with Claude Code and OpenCode, memories stored locally, with outcome-based scoring and two-lane retrieval.

Desktop App

Purchase on Gumroad

Ideal for

Developers who want the sidecar LLM and memory pipeline to run fully on their own hardware via Ollama or LM Studio, or who need MCP tools.

What this tier adds

Adds the GUI app, 100% local operation with Ollama or LM Studio, MCP tools, and the bundled sidecar LLM for memory processing; purchased on Gumroad.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • Running the retrieval pipeline means paying the token cost of a sidecar LLM summarizing, tagging, and fact-extracting every exchange, which compounds across long sessions.
  • Local inference via Ollama or LM Studio trades dollar cost for hardware — a machine that can't hold a capable model locally will slow every turn.
  • Because scoring moves slowly (worked +0.2, failed −0.3, partial +0.05), early sessions retrieve mostly untested memories, so the value compounds over time rather than on day one.
  • The free Core tier keeps memory on one machine with no cloud sync, so multi-device workflows mean manually moving or re-establishing the memory store.

Where the pricing makes sense

The company stage and team size where Roampal's pricing actually pencils out — and where peers do it cheaper.

Roampal's Core tier is free and open source (Apache 2.0) and covers Claude Code and OpenCode with local storage, which puts the entry point below cloud memory layers such as Mem0 or Zep that bill monthly for hosted memory. The desktop app is a one-time purchase on Gumroad and is where Ollama/LM Studio local inference and the MCP tools live. For a solo developer already running a local model, the effective cost is compute rather than subscription; the trade is that you give up the hosted sync

Setup time & first value

How long it actually takes to get something useful out of Roampal — broken out by persona, not the marketing-page minute.

For Claude Code or OpenCode users: a pip install roampal followed by roampal init auto-detects your tools, or you target one explicitly with --claude-code or --opencode. First useful context arrives once a few exchanges have been summarized, tagged, and scored, so expect the first session to be largely untested memories. For the local-model path via the desktop app, add the time to get Ollama or

Switching to or from Roampal

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From plain vector RAG you wired up yourself: point your coding agent at Roampal instead, since TagCascade adds tag-overlap sorting and cross-encoder reranking on top of ChromaDB lookups, plus outcome scoring your custom
  • →From no memory layer at all: install via pip, run roampal init to auto-detect Claude Code or OpenCode, and let the sidecar build summaries, facts, and tags from your first sessions.
  • →From cloud-based memory such as Mem0 or Zep: move to Roampal's local store if keeping memory on your own disk matters more than hosted sync across devices, accepting that scoring starts from zero and rebuilds over your
Migrating out
  • ↗To a hosted memory platform like Mem0 or Zep: you gain multi-device sync and managed infrastructure but give up outcome-based scoring, the working/history/patterns lifecycle, and fully local storage.
  • ↗To plain RAG in your own stack: you keep the vector store but lose TagCascade's tag-overlap tiers, cross-encoder reranking, and the worked/failed/partial feedback that adjusts memory scores.
  • ↗To a general assistant memory product: only if your work moves out of coding agents entirely, since Roampal's scope is Claude Code and OpenCode.

Integrations

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Roampal”, and we withheld 6: 6 could not be judged, because “Roampal” 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 Roampal.

Official links

Tools that pair well with Roampal

Common stack mates teams adopt alongside Roampal, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Roampal

View all
Pieces for Developers

Pieces for Developers

A desktop memory layer that captures your focused app every 2 seconds and pipes that history into MCP-ready AI assistants.

PaidTry
Codeium

Codeium

Devin Desktop is a free AI coding assistant and agent IDE with unlimited Tab completions and an Agent Command Center for fleets of local

FreemiumTry
Windsurf

Windsurf

Devin Desktop (formerly Windsurf) is an agent-native IDE for running fleets of local and cloud coding agents from one Sessions board.

FreemiumTry

Frequently Asked Questions

Used Roampal? Help shape our editorial sentiment research.