# Memtrace: structural memory for AI coding agents, in private beta > Memtrace builds a bi-temporal knowledge graph of a codebase and serves it to coding agents over MCP, with no LLM calls in the indexing path. Access is gated behind a waitlist, and the licence is a proprietary EULA rather than an open source one. **syncable-dev/memtrace-public** — Structural memory for AI coding agents. Bi-temporal graph, MCP-native, zero LLM calls. Cursor · Claude Code · Codex · DeepSeek Harness · Hermes · VS Code · Windsurf. - Repository: https://github.com/syncable-dev/memtrace-public - Website: https://memtrace.io - Stars: 487 · Forks: 47 - Language: Python - License: NOASSERTION - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/syncable-dev-memtrace-public ## What Memtrace solves for fleets of coding agents A single agent working in one session can hold a repository in its context window for a while. Two agents, or one agent returning the next morning, cannot. Each re-reads files, each rebuilds its own picture of what calls what, and the two pictures drift. The README frames this as the problem Memtrace exists to fix: "Run a fleet of coding agents on the same repo without merge hell." The claim is that every agent reads the same call graph, sees the same blast radius, and inherits the same history, so an edit one agent makes is visible to the others before they act on a stale view. The audience is narrow and specific. You need at least one agent that speaks MCP, a repository large enough that re-reading it is a real cost, and a reason to care about what changed between sessions. The README lists Cursor, Claude Code, Codex, DeepSeek Harness, Hermes, VS Code and Windsurf as supported hosts. A solo developer editing a small script has none of these problems, and installing a graph server to solve them adds a moving part for no return. ## The bi-temporal graph and the zero-LLM indexing path The mechanism is an AST graph with two extra dimensions. Parsing is done with Tree-sitter, and the README states the runtime is Rust and that indexing makes zero LLM calls, which is where the "$0 in API costs" claim comes from. Nodes are functions, classes and their call edges; the README says the graph covers "every function, class, call edge, and version, across every session." The temporal half is what the project calls bi-temporal. Ordinary code graphs answer what is in the repository now. Memtrace keeps symbol history so an agent can ask what a symbol looked like before a refactor, which is what makes the replay use case possible: "Agents see exactly what depends on what, and what changed when." Framework-aware scanners extend the graph beyond raw syntax, and the README names Vapor, Lapis, Kong, GitHub Actions, Terraform and RLS policies among them. Those scanners are where a lot of the practical value sits, because a Rails or Django call edge that only exists by convention is invisible to a pure parser. Agents reach the graph over MCP, so the integration is a server connection rather than a library you import. The README also documents LeanCTX Native, a set of compression modes on `get_source_window` plus single-call directory maps and a token-savings ledger, with an opt-in adaptive learner the README says beats the static table by about 14 percent. That number comes from the project's own documentation and is not independently verified here. ## Installing Memtrace and running a first query Access is gated. The README states Memtrace is in private beta and that you join the waitlist at memtrace.io before you can install. The npm package exists, but the README presents the install command as the step for people who already have access, so treat the waitlist as the real first step rather than something to skip. Once you are admitted, the global install is one command. The README gives `npm install -g memtrace` and says you are indexing in 90 seconds. ```bash npm install -g memtrace ``` If you run DeepSeek Harness, the README documents a second path: install Harness first, then add Memtrace as a plugin against the `web` profile. ```bash npm install -g @deepseek-ai/dsh npx -y @deepseek-ai/dsh plugin --profile web add github:syncable-dev/dsh-plugin-memtrace ``` After that, the README says to ask the agent to index the workspace and then pull blast radius, evolution, or an architecture briefing. The queries are issued in the agent's chat, not on a command line, because the graph is exposed through MCP. If you want to silence the telemetry the README describes, set the environment variable it documents before starting the server. ```bash export MEMTRACE_TELEMETRY=off ``` ## Where Memtrace is the wrong tool The licence is the first thing to settle. The repository metadata reports NOASSERTION, the README badge reads "Proprietary EULA", and the top-level LICENSE file is the governing text. That combination means you cannot assume the freedoms an open source licence grants, and the README does not spell out redistribution or commercial terms. Read LICENSE yourself; nothing here is legal advice. Second, the beta gate is a real constraint, not a formality. The README says access rolls out in batches, so a team that needs the tool today may simply not be able to install it. There is also no public issue tracker visible in the repository layout, which matters if you evaluate stability by reading bug reports before committing. The README directs feedback to a Discord server instead. Third, the network behaviour is worth a decision rather than a default. The README is unusually explicit that source code never leaves the machine and that the only traffic is license validation, aggregate node and edge counts, and opt-out crash telemetry, with no source, file paths or symbol names. That is a defensible design, but it is still traffic, and in an air-gapped or regulated environment even aggregate counts can be a blocker. The README does not document an offline licence mode. Finally, the benchmark table is the project's own. It is presented as reproducible, with ground truth taken from Python's `ast` and `pyright` LSP rather than from any tool's index, and the suite lives under `benchmarks/`. That is a better methodology than most, but the numbers are still self-reported and I have not run them. ## How Memtrace differs from GitNexus and CodeGrapherContext The README names both directly and positions Memtrace as building on the same AST foundation. The stated difference is time. GitNexus and CodeGrapherContext, in the README's framing, answer "what's in my repo right now." Memtrace adds a second axis so a symbol carries its own history and an agent can ask what depended on it at an earlier revision. That difference shows up in the benchmark table too. Memtrace and GitNexus are close on exact symbol query accuracy, 96.6 percent against 97.0 percent, and Memtrace claims the latency win there rather than the accuracy win. The larger gaps appear on graph callers recall for Django, 81.6 percent against 5.3 percent, and on hybrid accuracy, 73.9 percent against 38.6 percent. If your work is mostly single-session symbol lookup, the two tools look similar and the temporal layer is overhead you will not use. If your work is refactoring across sessions, the recall gap is the number that would decide it. Either way, these are the project's figures. ## Maintenance, releases and upgrade cost The repository is not archived, and the last push was on 2026-09-06, with v1.2.0 released the same day. The two prior releases, v1.1.12 and v1.1.11, landed on 2026-09-04 and 2026-09-03. That cadence suggests an active project, and the README reinforces it by describing cohorts where fixes ship from real bug reports inside a week. The upgrade surface is small because the tool is a global npm package plus an MCP server configuration. Moving between patch releases means rerunning the install and restarting the agent host; the README does not describe a migration step or a schema version you have to convert. That is the good news. The open question is what happens to an existing graph when the index format changes, and the README does not document that. The repository does carry release notes at several version levels, including v0.4.62 and v0.4.0, so the changelog trail is there to read before you upgrade in a team setting. Note that the published version numbers in the release list are ahead of the release-note filenames, which suggests the notes are not regenerated for every tag. ## Conclusion Memtrace suits teams already running several coding agents over one repository and willing to accept a waitlisted, proprietary tool to give them a shared call graph. It is the wrong pick if you need an OSI-approved licence, offline installation, or a public issue tracker to judge stability from. Before adopting, verify three things: that your cohort has been admitted at memtrace.io, that `npm install -g memtrace` resolves to the version you expect, and that your team accepts the network traffic the README enumerates (license validation, aggregate node and edge counts, opt-out crash telemetry), which you can turn off with MEMTRACE_TELEMETRY=off. ## FAQ ### Is Memtrace open source? No. The repository metadata reports NOASSERTION and the README badge reads Proprietary EULA, with the top-level LICENSE file holding the terms. The README does not summarise redistribution or commercial rights, so read LICENSE directly. ### How do I install Memtrace? Memtrace is in private beta, so the README directs you to join the waitlist at memtrace.io first. Once you have access, the README gives `npm install -g memtrace` as the install command. DeepSeek Harness users can instead add it as a plugin with `npx -y @deepseek-ai/dsh plugin --profile web add github:syncable-dev/dsh-plugin-memtrace`. ### Does Memtrace send my source code anywhere? The README states that source code never leaves the machine and that the only network traffic is license validation, aggregate node and edge counts, and opt-out crash telemetry, with no source, file paths or symbol names. Telemetry can be disabled with MEMTRACE_TELEMETRY=off. The README does not document an offline licence mode. ### Which coding agents does Memtrace work with? The README lists Cursor, Claude Code, Codex, DeepSeek Harness, Hermes, VS Code and Windsurf, and describes the integration as MCP-native. DeepSeek Harness has a dedicated plugin repository at syncable-dev/dsh-plugin-memtrace. ## Sources - [Issues](https://github.com/syncable-dev/memtrace-public/issues) - [Project website](https://memtrace.io) - [README](https://github.com/syncable-dev/memtrace-public/blob/main/README.md) - [Releases](https://github.com/syncable-dev/memtrace-public/releases) - [syncable-dev/memtrace-public on GitHub](https://github.com/syncable-dev/memtrace-public) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/syncable-dev-memtrace-public