Memtrace Public

Memtrace Public

Shared structural memory that gives multiple AI coding agents one live code map of your repository.

60/100MonitorFree planFreemium

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

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
  • Platform teams coordinating parallel agent and human work
Not ideal for
  • Single-agent setups on small repos, where value drops sharply against setup cost
  • Teams that cannot grant coding agents file-write permissions
Visit Website

AdvancedRoughly 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.CLI · PluginAPI availableVerified 1d ago
Pricing
Free plan
FreemiumFree tier1 hidden cost
Learning curve
Advanced
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.
Runs on
CLIPlugin
API available · 7 integrations
Who it's for
Platform lead running three agents (Cursor, Claude Code, Codex) on a monorepoEngineer fixing an auth regressionNew engineer joining a team that inherited a large C#/Python codebase
Live sentiment
Is Memtrace Public 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 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 30-second take
Biggest gripe

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.

Price reality

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 yesterday

Across the latest 5 updates: 1 feature update and 4 changelog entries.

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.

100% positive0% critical

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

Recurring strengths
  • +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).
Recurring frustrations
  • −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.
Patterns worth knowing
Potential to reduce token costs and improve code quality for AI agent teams.
Seen on Hacker News
Innovative approach to shared memory using bi-temporal graphs.
Seen on Hacker News
Early-stage product with no public access, making evaluation impossible.
Seen on Hacker News
Learning curve
beginnerProductive in ~Unknown (waitlist only)
Hidden costs people mention
  • • No pricing available; may require paid tiers for production use.

Viability Score

60/100
Monitor

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

Recent activity
90
Traction
20
Site health
95
User sentiment
100
What the vendor publishes
40

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

FreemiumAdvancedAPI availableCLI · Plugin

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.

Platform lead running three agents (Cursor, Claude Code, Codex) on a monorepo

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.

Engineer fixing an auth regression

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.

New engineer joining a team that inherited a large C#/Python codebase

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

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.

  1. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  2. — re-checked, vendor evidence unchanged
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  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
—
—

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.

Hidden costs & gotchas

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

  • 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.

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.

Migrating in
  • →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.
Migrating out
  • ↗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

CursorClaude CodeCodexGemini CLIWindsurfVS CodeGitHub

Resources & Guides

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.

Tools that pair well with Memtrace Public

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

Featured Head-to-Head Comparisons

Alternatives to Memtrace Public

View all
Chrome DevTools MCP

Chrome DevTools MCP

Open-source MCP server that gives coding agents live Chrome DevTools access for debugging, automation, and performance traces.

FreeTry
QuantDinger

QuantDinger

Open-source, self-hosted AI quant trading platform that carries one Python strategy contract from backtest to live execution.

FreemiumTry
Dbhub

Dbhub

Minimal database MCP server that gives MCP clients one gateway to PostgreSQL, MySQL, SQL Server, MariaDB, Oracle, and SQLite

FreeTry

Frequently Asked Questions

Used Memtrace Public? Help shape our editorial sentiment research.