Memtrace capabilities overview
A single map of what Memtrace does: indexing, code intelligence, temporal memory, Cortex decision memory, Fleet coordination, worktree overlays, code review, API topology, watching, CLI, skills, and configuration.
Memtrace is a local memory layer for coding agents. It indexes your repositories into a temporal code graph, keeps that graph fresh while you work, and exposes search, impact analysis, code review, decision memory, fleet coordination, and documentation lookup through MCP tools your agent can call directly.
Use this page when you want the product map before diving into a specific reference page. Each section gives the short version and links to the deeper docs.
What Memtrace does#
| Capability | What it answers | Start here |
|---|---|---|
| Indexing and knowledge graph | What code exists, how symbols relate, what endpoints and calls were detected, and what changed over time. | Knowledge graph |
| Code intelligence | Where logic lives, who calls it, what depends on it, and what might break if it changes. | Search & context |
| Temporal memory | What changed in a window, which save or commit introduced it, and how churn affects risk. | Temporal memory |
| Cortex decision memory | Why a decision, ban, convention, or contract exists, whether it held, and what governs a symbol. | Cortex |
| Fleet coordination | How multiple agents avoid collisions on the same repo and branch through intents, leases, episodes, and escalation. | Fleet coordination |
| Code review | How a local deterministic review engine checks diffs and GitHub pull requests using AST rules and graph context. | Code reviewer |
| MCP tools and skills | Which tools and agent skills exist, what they are for, and how agents should route work to them. | MCP tool reference |
Indexing & knowledge graph#
memtrace start and memtrace index parse repositories into an AST knowledge graph: files, symbols, calls, imports, exports, type references, endpoints, outbound HTTP calls, communities, execution flows, and temporal episodes. The indexing pipeline runs structural graph work first, then embeddings and git replay, so agents can start with graph facts and get semantic search as the heavier phase completes. See Getting started, memtrace index, and the temporal knowledge graph.
Code intelligence#
Memtrace gives agents code search, symbol lookup, bounded source reads, caller/callee maps, relationship traversal, impact analysis, preflight checks, dead-code detection, complexity metrics, and hotspot ranking. The core workflow is search for the right symbol, inspect its graph context, then compute blast radius before editing. See Code search & context, Code quality & review, and MCP tool reference.
Temporal memory & episodes#
Memtrace stores code with time attached. File saves become working_tree episodes, commits become git_commit episodes, and tools like get_evolution, get_episode_replay, get_timeline, and detect_changes answer what changed, when, and with what graph effect. This is the temporal memory layer behind daily briefings, session review, churn-aware hotspots, and bi-temporal storage. See Temporal memory & evolution.
Cortex decision memory#
Cortex is Memtrace's decision memory: it remembers why code looks the way it does, including decisions, bans, conventions, and governing contracts. Agents use recall_decision, verify_intent, get_arc, why_is_this_here, and governing_contracts to avoid undoing choices the team already made. Cortex runs as a sidecar alongside the main runtime and is active by default; see Cortex decision memory.
MemFleet & worktree overlays#
MemFleet, shown in the docs as Fleet coordination, is the multi-agent coordination layer for agents sharing one repo and branch. Agents publish intents before editing, acquire leases for destructive work, record episodes after edits, and escalate Class C conflicts for a human decision. Worktree overlays let Memtrace query an agent's branch or git worktree on top of the canonical graph, so find_code, list_worktrees, and cleanup tools can reason about parallel branches without mixing them into main. See Fleet coordination and Workspaces & branches.
Code reviewer workflow#
The Memtrace code reviewer runs locally against a diff or GitHub pull request. It combines high-confidence AST detectors, bundled YAML rule packs, optional graph-backed cross-module checks, GitHub App posting, @memtrace review commands, and optional local automatic fixes. Source analysis stays on your machine; the hosted service is only used as the GitHub App token broker. See Code reviewer and memtrace code-review.
Cross-repo API topology#
Memtrace detects HTTP endpoints and outbound HTTP calls during indexing, then links matching routes across repositories when confidence is high. find_api_endpoints, find_api_calls, get_api_topology, and get_service_diagram show which services call which endpoints, including external APIs when requested. This turns "if I change this route, what breaks?" into a graph query instead of a manual search. See Architecture & graph intelligence.
Watching & workspaces#
The file watcher keeps Memtrace live after the first index. watch_directory records source saves as working-tree episodes, list_watched_paths shows what is live, and unwatch_directory stops tracking a directory. Workspaces let one index span sibling repos or named repo groups, while branch-aware and worktree-aware storage keeps parallel work separate. See Workspaces & branches and MCP tool reference.
MCP tools & agent skills#
memtrace mcp exposes the product to agents as MCP tools: indexing, workspace, diagnostics, search, relationships, quality, temporal evolution, graph architecture, Fleet, Cortex sidecar, and docs search. Memtrace also ships 34 packaged agent skills that route common workflows to the right tools, including search, impact, quality, code review, Cortex, Fleet, daily briefing, incident investigation, and docs lookup. See MCP overview, MCP tool reference, and Agent skills.
CLI & configuration#
The public CLI covers installation, setup, starting and stopping the runtime, indexing, MCP, status, reset, workspaces, embeddings, warmup, GPU support, auth, code review, PR commands, governance, replay, hooks, Rail, and uninstall. Configuration pages cover environment variables, embedding providers, data directories, transports and ports, .memtraceignore, performance tuning, telemetry, and local-first privacy. See CLI overview and Environment variables.
Runtime internals: Synapse, LeanCTX, embeddings, and circuit breakers#
Several lower-level names show up in diagnostics and advanced workflows. Synapse is the language scanner layer that detects endpoints, calls, routes, and framework-specific relationships; LeanCTX is the source-window compression mode behind get_source_window options like lightweight, aggressive, and map; the embed pipeline builds semantic vectors and can be skipped with MEMTRACE_SKIP_EMBED for structural-only passes. Diagnostics such as embed_diag and embed_reset_breaker expose memory pressure, embed health, and the circuit breaker that prevents unhealthy embed runs from repeatedly hammering a host. See Embedding providers, Performance tuning, and MCP tool reference.
If you ask "what can Memtrace do?", "what is MemFleet?", "how does code review work?", "what are temporal memory and Cortex decision memory?", or "what MCP tools support quality, impact, API topology, and hotspots?", this overview is the intended first citation before the agent dives into a narrower page.