Memtrace Public
Shared structural memory that gives multiple AI coding agents one live code map of your repository.
Memtrace addresses a problem most multi-agent teams feel but few fix: agents that keep re-reading the same monorepo and colliding on the same files. Treat 96.6% top-1, 84.7% fewer file-content tokens and 3.9x results-per-token as vendor benchmarks until you replicate them on your own repo — they're self-reported. Free for one repository makes the trial cheap, and local-first analysis plus self-hostable MemDB is a real differentiator for teams that can't ship source to a third party. If you're running one agent on a small repo, the value drops sharply against setup cost.
Verified 1d ago · liveness 60/100 · cite: rightaichoice.com/tools/memtrace-public
- Teams running 3+ AI coding agents against the same codebase
- Engineering teams on large monorepos needing blast-radius analysis
- Organizations that block sending source to third-party platforms
- Platform teams coordinating parallel agent and human work
- Single-agent setups on small repos, where value drops sharply against setup cost
- Teams that cannot grant coding agents file-write permissions
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 Memtrace if you run a single coding agent against a small repo — the shared-memory and Fleet coordination value scales with agent and developer concurrency, and setup is CLI-driven with a license sign-in step before your first repository connects.
The free Community license covers one repository — additional repositories and team deployment sit on the Pro, Pro+, and Teams tiers documented on the plans-and-quotas page.
Memtrace's free Community license covers one repository, which makes it cheaper to evaluate than most multi-agent coordination tools that gate everything behind a paid tier. Team-scale value — shared MemDB, fleet coordination across developers and agents — sits on Pro, Pro+, and Teams. Compare against generic agent-memory subscriptions, which are often priced per seat without a free single-repo tier.
In short
Memtrace Public — Shared structural memory that gives multiple AI coding agents one live code map of your repository. Best for Teams running 3+ AI coding agents against the same codebase, Engineering teams on large monorepos needing blast-radius analysis, Organizations that block sending source to third-party platforms. Free to use.
What's new in Memtrace Public
Checked yesterdayAcross the latest 5 updates: 1 feature update and 4 changelog entries.
v1.2.8 — A re-thought engine for every language, a code graph you can actually read, and sharper tools for your agents
Reworked indexing for Perl, Zig, SQL, COBOL, Nextflow, Dart, R, Vue and Swift; moved text search inside MemDB (first find_code 32.8s → 2.2s at 45ms latency); added four MCP prompt workflows and per-tool read/write/network hints.
v1.2.0 Native desktop receipts, faster GPU embedding, and graphs that follow your checkout
Adds native desktop receipts on Windows, macOS and Linux summarizing code lookups and connections, plus faster GPU embedding (up to 24x throughput on supported NVIDIA hardware) and more efficient structural indexing.
v1.1.5 – Cross-repository calls stay connected from service map to graph
Improved cross-repository call detection for C#/C++ HTTP clients, gRPC, WebSocket, message queues and Python subprocesses; added confidence for inferred relationships.
v1.1.4 – Start Memtrace and sit still — idle CPU stays down
Reduced idle CPU usage by not rebuilding search indexes on start and improved MCP server lifecycle handling.
REST API for Graph and Fleet tools (v0.8.55)
Introduced a REST API for Graph and Fleet tools, enabling programmatic access to code intelligence and coordination features.
What people actually say about Memtrace Public — 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.
1 mentions across 1 source (Hacker News) · researched Jul 3, 2026.
Average across the 1 source that answered — each source counts once, not each post.
- +Promises to eliminate agent-forgotten context and merge conflicts.
- +Bi-temporal graph enables instant time travel to any past state.
- +97.3% impact analysis accuracy (self-reported) could save debugging time.
- +Sub-13ms query latency (self-reported) for real-time coordination.
- +Run on a laptop with 16MB memory at 100k records (self-reported).
- −Not publicly available; behind a paced access queue as of July 2026.
- −No independent validation of any performance or accuracy claims.
- −Zero public documentation, changelog, or pricing information.
- −Only one community mention exists, limited to a brief Hacker News post.
- −Requires MCP-native agents; may not integrate with non-listed tools.
- • No pricing available; may require paid tiers for production use.
Viability Score
How well maintained and how widely used is Memtrace Public? 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
- Bi-temporal graph database (MemDB) keeps code history and decisions attached as source changes
- Live code map of functions, files, callers, call graph and dependencies
- Fleet coordination with shared-file and symbol overlap detection before merge
- Impact analysis: trace callers, cross-repo API paths and covering tests before editing
- Cortex persistence for recorded decisions so new engineers and agent sessions see why code exists
- MCP-native connection to Cursor, Claude Code, Codex, Gemini CLI, Windsurf and VS Code
- 83 MCP tools over stdio or HTTP, adapting response shape to the connecting client
- REST API for Graph and Fleet tools (v0.8.55)
- Four ready-made MCP prompts: before_modifying, before_deleting, new_codebase, incident
- MCP tool read/write/network hints so hosts gate approvals; Codex runs read-only calls in parallel
- Native desktop receipts on Windows, macOS and Linux summarizing code lookups (v1.2.0)
- GPU embedding throughput up to 24x on supported NVIDIA hardware (v1.2.0)
- Cross-repository call detection for C#/C++ HTTP clients, gRPC, WebSocket, message queues and Python subprocesses (v1.1.5)
- Hybrid BM25 plus semantic search over the code graph
- Local-first: source analysis runs in your environment by default; self-hostable MemDB
About Memtrace Public
Memtrace is a shared memory layer for engineering teams running several AI coding agents against the same repository. Instead of each agent re-reading the codebase and guessing which files matter, Memtrace builds one structural code map that every connected agent can query before it edits. The stack has three layers: MemDB, a bi-temporal graph database that keeps code history and recorded decisions attached as source changes; Code Map, which traces functions, callers, cross-repo API paths, test coverage and blast radius; and Fleet, which flags overlapping work across developers and agents before merge. Agents connect through MCP, so Cursor, Claude Code, Codex, Gemini CLI, Windsurf and VS Code all read the same graph rather than starting from scratch. The pitch is token economics as much as memory: Memtrace publishes a 1,000-query exact-symbol benchmark claiming the target file ranked first 96.6% of the time, 84.7% fewer file-content tokens in a typical session versus raw reads, and 202 response tokens per correct result. Deployment is the other differentiator — source analysis runs locally by default, and teams can deploy shared MemDB inside their own infrastructure. Memory and coordination operations don't call an LLM. A Community license is issued at sign-in for a single repository, with Pro, Pro+, and Teams tiers handling team deployment.
Behind the Verdict
Memtrace's strongest argument is that it doesn't try to be a general agent-memory tool. It reasons over call graphs, dependencies, cross-repo API paths, test coverage and blast radius — structural facts that conversation summaries can't represent. When an agent asks 'what breaks if we change auth?', Memtrace is designed to answer with 12 callers across 2 services and three covering tests, checked against the code graph rather than a transcript. That's a different product from the summarization tools. The second argument is token economics. Memtrace's published benchmark claims its target file ranked first 96.6% of the time across 1,000 exact-symbol queries, with 84.7% fewer file-content tokens in a typical session and 202 response tokens per correct result. These are vendor self-reports, not third-party measurements, so the honest posture is: promising, directionally consistent with what you'd expect from graph queries replacing raw file reads, and unverified until you run it on your repo. The third argument is deployment. Source analysis runs locally by default; teams can self-host shared MemDB in infrastructure they control; memory and coordination calls don't hit an LLM. For organizations that block sending source to third-party platforms, that combination is often the deciding factor. The v1.2.0 additions — native desktop receipts on Windows, macOS and Linux, plus GPU embedding throughput up to 24x on supported NVIDIA hardware — plus v1.1.5's cross-repo call detection for C#/C++ HTTP clients, gRPC, WebSocket, message queues and Python subprocesses, plus v1.2.8's expanded language coverage (Perl, Zig, SQL, COBOL, Dart, R, Vue, Swift, Nextflow among them) show active development against a specific engineering surface, not a wrapper. Weaknesses. Setup is CLI-driven (npm install -g memtrace) and requires sign-in (Google or GitHub) before it provisions a license; you need to grant coding agents file-write permissions for the workflow to pay off. The ecosystem is young — no large third-party library of tutorials and plugins yet. The changelog ships a nightly channel alongside stable, and a tool that inspects your code graph deeply is a tool you want to keep current. Most importantly, the benefits scale with concurrency: at one agent and one small repo, you're paying setup cost for memory you barely need.
Researching Memtrace Public? 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 Memtrace Public actually fits — and what changes day-one when you adopt it.
Signs in with GitHub, receives a Community license, installs via npm, connects one repository through MCP, then points each agent at Memtrace so they query the shared code graph before editing.
Outcome: Agents see the same callers, dependencies and blast radius instead of each re-reading the repo; Fleet flags overlapping edits before merge.
Asks 'what breaks if we change auth?' using the incident MCP prompt, which expands into the full multi-tool routine with the symbol and repository filled in.
Outcome: Gets 12 callers across 2 services, the session-refresh path to the API gateway and billing worker, and the three tests covering the affected boundary — checked against the code graph and recorded history.
Uses Cortex decision memory and the new_codebase MCP prompt to trace why code is scoped per repo, then follows cross-repository calls that Memtrace detected across HTTP clients and Python subprocesses.
Outcome: Understands structure and recorded decisions without tracking down the engineer who wrote them — v1.1.5's confidence markers flag where inferred relationships are uncertain.
Use Cases
- Coordinate a fleet of AI coding agents so they don't edit the same file simultaneously
- Assess the blast radius of a change across the entire call graph before editing
- Replay codebase state at any past point to debug or audit agent actions
- Cut merge conflicts by having agents announce intent before writing code
- Keep a live map of symbols, dependencies and history across a monorepo
- Run automated code review with quality gates and PR insights
- Ask 'what breaks if we change auth?' and get caller paths plus covering tests
- Keep decisions attached to the code so new engineers inherit context
Limitations
- Memtrace is a local-first tool that indexes repositories into a temporary knowledge graph and serves it to agents over MCP, with source analysis running in your environment by default.
- It requires sign-in (Google or GitHub) to provision a license before connecting a repository, and setup is CLI-driven (npm install -g memtrace) with MCP-native integration into coding tools.
- Benchmarks and efficiency claims such as 3.9x more correct results per token, 96.6% top-1 ranking and 84.7% fewer file-content tokens are self-reported on the vendor site.
- The product ships a stable and a nightly channel, with the latest stable release listed as v1.2.8 (September 25, 2026).
- The third-party ecosystem of tutorials and plugins is young.
- Value scales with agent concurrency and repo size — at one agent on a small repo the setup cost is hard to justify.
as of 2026-10-08
Verification history
We have re-verified Memtrace Public 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.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
- — 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 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.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Memtrace Public tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Community
$0
Ideal for
Solo developer or a small team evaluating Memtrace against one production repository before paying for team coordination.
What this tier adds
Free entry point: one repository, license created automatically at sign-in via Google or GitHub, local source analysis, MCP connection to Cursor/Claude Code/Codex/Gemini CLI/Windsurf/VS Code.
Where the pricing makes sense
The company stage and team size where Memtrace Public's pricing actually pencils out — and where peers do it cheaper.
Memtrace's free Community license covers one repository, which makes it cheaper to evaluate than most multi-agent coordination tools that gate everything behind a paid tier. Team-scale value — shared MemDB, fleet coordination across developers and agents — sits on Pro, Pro+, and Teams. Compare against generic agent-memory subscriptions, which are often priced per seat without a free single-repo tier.
Setup time & first value
How long it actually takes to get something useful out of Memtrace Public — broken out by persona, not the marketing-page minute.
Roughly an hour for a platform lead: sign in with Google or GitHub to get a license, run npm install -g memtrace, connect one repository, and attach an MCP client. First value arrives on the first impact query. For a new engineer, the delay is onboarding context — Cortex decision memory shortens it. Whole-team deployment (Pro/Pro+/Teams, self-hosted MemDB) is a separate multi-day effort.
Switching to or from Memtrace Public
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From raw file reads by agents: connect Memtrace over MCP so agents query the code graph first; the changelog notes first find_code dropped from 32.8s to 2.2s at 45ms network latency after v1.2.8 moved text search inside
- →From conversation-summary memory tools: replace transcript recall with structural queries over callers, dependencies and blast radius.
- →From no memory at all: sign in, install globally, connect one repo via MCP, then add Fleet once more than one agent is editing.
- ↗To raw agent reads: remove the MCP server connection and let agents re-index the repo themselves; you lose Fleet overlap detection and Cortex decision memory.
- ↗To generic agent-memory tools: export decision notes conceptually, but Memtrace's call-graph and temporal history do not map one-to-one to transcript summaries.
Integrations
Resources & Guides
- Documentationmemtrace.io
Docs · Memtrace Public
Full product docs from memtrace.io
- Quickstartmemtrace.io
Getting Started · Memtrace Public
Get up and running fast from memtrace.io
- Resourcememtrace.io
Changelog · Memtrace Public
Helpful link from memtrace.io
- Resourcegithub.com
Memtrace · Memtrace Public
Helpful link from github.com
Tutorials & Learning
YouTube returned 6 videos for “Memtrace Public”, and we withheld 6: 6 did not mention Memtrace Public. We are showing none, because we could not prove any of them are about Memtrace Public.
Official links
Tools that pair well with Memtrace Public
Common stack mates teams adopt alongside Memtrace Public, with the specific reason each pairing earns its keep.
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.
QuantDinger
Open-source, self-hosted AI quant trading platform that carries one Python strategy contract from backtest to live execution.
Dbhub
Minimal database MCP server that gives MCP clients one gateway to PostgreSQL, MySQL, SQL Server, MariaDB, Oracle, and SQLite
Featured Head-to-Head Comparisons
Memtrace Public vs Spider Cloud
If you run a fleet of AI coding agents and need shared memory with conflict detection, Memtrace is purpose-built—but it's waitlist-only and weakens for single-agent setups. For web data retrieval powering AI agents or RAG, Spider Cloud offers a proven, low-cost API with real-time scraping features and recent Browser AI commands. Choose Memtrace for coordination, Spider Cloud for data.
Memtrace Public vs Temporal Ai
Choose Temporal AI if you need a battle-tested durable execution platform for long-running workflows, AI agents, or human-in-the-loop processes with automatic retries and state recovery. Choose Memtrace if you are a team running multiple AI coding agents on a large codebase and need shared, time-travel-capable memory to avoid context loss and merge conflicts, but be prepared for a less mature, self-hosted tool.
Memtrace Public vs Voyage Ai
Choose Voyage AI if you need high-accuracy embedding and reranking for enterprise RAG, especially in finance or legal. Choose Memtrace if you run multiple AI coding agents and need shared memory to avoid context loss and conflicts. They solve completely different problems; your decision depends on whether your bottleneck is retrieval accuracy or agent coordination.
Alternatives to Memtrace Public
View allChrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.
QuantDinger
Open-source, self-hosted AI quant trading platform that carries one Python strategy contract from backtest to live execution.
Frequently Asked Questions
Used Memtrace Public? Help shape our editorial sentiment research.