Skip to content
Why Graphicle

One program, not a stack.

The code graph, the memory, one MCP server, the web app and the command line come in one install. No Python, Docker or database server.

Graphicle, or a code-graph tool plus a memory server

A code-graph tool + a memory serverGraphicle
InstallTwo tools, often on different runtimes, and often a database serverOne install
Connect your agentsConfigure each tool in each agentOne command, graphicle setup
MCP servers in your agentTwo, configured separatelyOne, with the graph and the memory tools
StorageGraph files plus the memory server's databaseOne SQLite file in one data folder
Code structure: calls, imports, impactThe graph toolgraphicle graph
Docs, decisions, past sessionsThe memory serverBuilt in
Citations and reviewVariesA file and its lines on every excerpt; agent memories wait for approval

The left column is a code-graph tool, such as Graphify's open-source engine, plus a separate memory server. It is not a comparison with Graphify Cloud, a hosted service that includes memory. Graphicle against Graphify, Mem0, Hindsight and others

Memory

Memory, without a separate memory server.

It runs in the same program as the code graph. Its memory library adapts parts of open-source memory systems, among them Hindsight, Mem0 and Graphiti, credited in its notices.

  • Cited context, within a budget you set

    Your agent asks Graphicle and gets the relevant code, docs and decisions as cited excerpts, within a token budget you set. In our tests it tied grep on finding code, and we do not claim it saves tokens. What we measured

  • Project memory

    Docs (Markdown, PDF, Office, HTML), reviewed decisions and procedures, and past Claude Code and Codex sessions, searchable alongside the code.

  • Tied to your code

    A reviewed memory is tied to the function it is about, and goes stale when that code changes. In a 30-note sample, the 15 notes whose function changed were flagged and no other; a wider exploratory check found some false flags. Details and limits

  • Sessions carry over

    Session capture keeps each finished turn, and once you have reviewed memories, each new session starts with them and the latest turns.

  • Forgetting with a receipt

    Deleting a memory or a captured session also removes what was derived from it, and you get a hash-chained deletion receipt.

  • Local and private

    No account and no telemetry: your code and data leave your machine only when you ask. The only automatic request is a check for a new release, at most once a day, which GRAPHICLE_NO_UPDATE_NOTIFIER=1 turns off. Recall and session capture need no model or API key; proposing memories from sources uses one, and local models through Ollama work. Privacy details

Measured

Against seven memory systems.

Graphicle and seven memory systems answered the same questions, under a protocol written before any answer was scored. Graphicle against each one

LoCoMo-10, 1,540 questions

Accuracy, points out of 100 · higher is better

LoCoMo-10 accuracy of Graphicle and seven memory systems on the weak reader, in points out of 100, with 95% intervals and each system's registered comparison with Graphicle.
SystemAccuracy
Graphicle
87.66, 95% interval 85.13 to 90.20; Graphicle: a pre-release build with an evaluation renderer that does not ship
Hindsight
87.27, 95% interval 85.63 to 89.06; Hindsight 0.10.2, observations on; Graphicle +0.39 [−0.80, +1.57], a tie. Hindsight's published contexts, read the same way: 88.18 [86.31, 90.29], also a tie
Mem0 OSS
81.88, 95% interval 79.59 to 84.36; Mem0 OSS 2.2.1, with dates; Graphicle +5.78 [+3.99, +7.23], ahead under the registered rule
MemMachine
79.55, 95% interval 77.26 to 81.97; MemMachine 0.4.0; Graphicle +8.12 [+5.95, +10.24], ahead under the registered rule
Honcho
79.16, 95% interval 76.21 to 82.15; Honcho 3.2.2; Graphicle +8.51 [+6.90, +9.96], ahead under the registered rule
Cognee
69.48, 95% interval 67.32 to 71.24; Cognee 1.6.3; Graphicle +18.18 [+15.43, +21.18], ahead under the registered rule
Graphiti
46.49, 95% interval 43.99 to 48.88; Graphiti (graphiti-core 0.30.2); Graphicle +41.17 [+37.68, +44.76], ahead under the registered rule
Mastra OM
38.57, 95% interval 33.56 to 43.10; Mastra Observational Memory (@mastra/memory 1.36.0); Graphicle +49.09 [+43.93, +54.58], ahead under the registered rule
The weak reader, the primary measure, with every system in its best declared configuration; the open model was Qwen3.8-27B-FP8. Graphicle's context composition was chosen on LoCoMo-10 with this reader and judge, and it ran with an evaluation renderer that does not ship. Versions: Hindsight 0.10.2 with observations on; Mem0 OSS 2.2.1, the open-source library, not Mem0's hosted platform; MemMachine 0.4.0; Honcho 3.2.2; Cognee 1.6.3; graphiti-core 0.30.2; @mastra/memory 1.36.0. Hindsight's published contexts, read by the same reader and judge, scored 88.18, a tie with Graphicle.
  • 13 of 21registered comparisons Graphicle led, across three development sets; 4 ties, none behind
  • 12 vs 160 vs 332estimated model calls per conversation while ingesting LoCoMo-10: Graphicle, Hindsight 0.10.2, Mem0 OSS 2.2.1
  • 43K vs 1.14M vs 3.18Mestimated prompt tokens per conversation in the same runs

A pre-release comparison with seven memory systems: development sets; one open model as every system's reader, judge and model; a pre-release build of Graphicle, not its released defaults. These scores cannot be set against any vendor's published numbers, and the call counts per conversation are estimates. Of the 21 registered comparisons, 3 led without meeting every condition of the rule and 1 was not run. Every score, with its method and caveats. The early pre-release evaluations on GPT models, wins and losses, are on the comparison page.

Speed

Native speed.

On 13 codebases, Graphicle's 0.1.1 memory engine (a pre-release build) took 3.0 to 22.7 times less time than Graphify 0.9.91 in all 39 measurements: a code-only extract, a priming update and an update with no change on each. Every measurement. A later pre-release build, whose graphs also differ from Graphify's, used less peak memory than Graphify 0.9.91 in all 39 measurements, from 0.29 to 0.97 times Graphify's figure (memory table).

Code-only extract, 13 codebases

Graphify 0.9.91's time ÷ Graphicle's · higher is less time

How many times less time Graphicle's 0.1.1 memory engine took than Graphify 0.9.91 for a code-only extract of 13 codebases, with the range across each codebase's three operations.
CodebaseTimes less time
kubernetes
22.7×, 68.3 s against 1,546.9 s; 17.1× to 22.7× across its 3 operations
rails
7.0×, 12.1 s against 84.9 s; 7× to 7.3× across its 3 operations
flask
6.9×, 0.34 s against 2.39 s; 6× to 8.1× across its 3 operations
prometheus
6.6×, 3.63 s against 23.9 s; 6× to 6.6× across its 3 operations
react
6.2×, 11.8 s against 73.3 s; 5.7× to 6.2× across its 3 operations
scikit-learn
6.1×, 5.84 s against 35.5 s; 6.1× to 6.5× across its 3 operations
pandas
5.8×, 10.9 s against 62.4 s; 5.8× to 6.8× across its 3 operations
vscode
5.4×, 115.6 s against 624.5 s; 5× to 5.6× across its 3 operations
ripgrep
5.3×, 0.48 s against 2.54 s; 4.2× to 5.3× across its 3 operations
tokio
5.1×, 1.52 s against 7.77 s; 4.5× to 5.1× across its 3 operations
redis
4.3×, 3.53 s against 15.3 s; 4× to 4.7× across its 3 operations
next.js
4.0×, 93.5 s against 370.7 s; 3.3× to 4× across its 3 operations
spring-boot
3.3×, 37.7 s against 125.9 s; 3× to 4.3× across its 3 operations
Graphicle's 0.1.1 memory engine (a pre-release build, not the released binary) against Graphify 0.9.91, on the same machine with 3 CPUs and 8 workers each, 15 October 2026; median of 3 runs (1 for Kubernetes and VS Code). The graphs differ slightly: node counts within 4.7%, edge counts within 2.0%. In every measurement, Graphicle's slowest run took less time than Graphify's fastest.
Retrieval

Finding the files a fix changes.

Offline ranking, 100 SWE-bench Verified issues never used for tuning. Graphicle 0.1.3 put a file the fix changed in its first 5 files for 75 issues, against 61 for BM25 (SWE-bench style), a significant difference (McNemar exact p = 0.013); for the first file (43 vs 35) and the first 10 (82 vs 77) the differences are not significant. This measures ranking, not whether a coding agent fixes more issues; the agent test of 0.1.3 is pending. Method, task lists and limits

Finding the files a fix changes: 100 SWE-bench Verified issues, held out from tuning. Top 1: Graphicle 0.1.3 43, Graphicle 0.1.2 13, BM25 (SWE-bench style) 35, grep for the issue's names 20; Top 5: Graphicle 0.1.3 75, Graphicle 0.1.2 30, BM25 (SWE-bench style) 61, grep for the issue's names 54; Top 10: Graphicle 0.1.3 82, Graphicle 0.1.2 30, BM25 (SWE-bench style) 77, grep for the issue's names 71; MRR: Graphicle 0.1.3 0.562, Graphicle 0.1.2 0.191, BM25 (SWE-bench style) 0.478, grep for the issue's names 0.365.Finding the files a fix changes: 100 SWE-bench Verified issues, held out from tuning. Top 1: Graphicle 0.1.3 43, Graphicle 0.1.2 13, BM25 (SWE-bench style) 35, grep for the issue's names 20; Top 5: Graphicle 0.1.3 75, Graphicle 0.1.2 30, BM25 (SWE-bench style) 61, grep for the issue's names 54; Top 10: Graphicle 0.1.3 82, Graphicle 0.1.2 30, BM25 (SWE-bench style) 77, grep for the issue's names 71; MRR: Graphicle 0.1.3 0.562, Graphicle 0.1.2 0.191, BM25 (SWE-bench style) 0.478, grep for the issue's names 0.365.
How it works

Sync, recall, remember.

Your project

  • CodeFiles, functions, classes, calls and imports
  • DocumentsREADMEs, notes and decisions, versioned
  • Agent sessionsFinished turns, captured with credentials redacted

One program, on your machine

graphicleone command, one data folder
Code graphBuilt on every sync; recall uses it to pull in related code, such as callers
MemoryCited excerpts from every source. Agents propose memories; you approve them.

Where you use it

  • MCPYour coding agentsMCP tools: cited context and your reviewed memories
  • CLIgraphicle askCited evidence, or an answer from a model you set up
  • appgraphicle openThe graph and memory in your browser
Changed files sync before each answerNo account, no telemetry; your code and data leave your machine only when you askThe only automatic request: a check for a new release, at most once a day
  1. Sync

    Graphicle reads the folder, respects .gitignore and skips secrets, keeps a versioned copy of each source and builds the code graph.

  2. Recall

    When your agent calls a tool, Graphicle syncs what changed, ranks excerpts from code, documents, sessions and reviewed memory, and returns them with citations. The tools call no model.

  3. Remember

    Captured sessions become sources. Memories that agents propose wait for your approval in the app.

For teams

Free and
open source.

Graphicle is free and open source under Apache-2.0, for individuals and teams alike. A commercial edition for teams is in private preview.