Cogram

Remembers how past bugs got fixed. Decays with use, never deletes.

This page is the live demo — the full concept graph is loaded in your browser. Type any bug description below (or click a suggestion) and watch it recall real fixes with exact file:line provenance. Nothing to install.

Recall cost for this query
160 vs — raw tokens
≈15,822× less
600 Drag back in time — edges fade toward floor ε but never vanish.
Faded edges = forgotten but recoverable (decay → floor ε, never zero). Built from 600 real SWE-agent trajectories, zero LLM calls.

What this saves, in dollars

The naive way to give an agent memory is to replay its history into the context window — measured at ~109k tokens per question on LongMemEval. A Cogram recall is ~300 tokens for the same answer quality (see benchmark below). At $3 per million input tokens, that's $0.33 vs. $0.001 per lookup — for a team running 1,000 agent memory lookups a day, roughly $120k/year vs. $330/year. And because recall is pure graph traversal with zero LLM calls, it returns in milliseconds instead of waiting on a 100k-token prompt.

Path to adoption

Now: open-source core, pip-installable into any Python agent loop in two lines (below) — CC BY-NC-SA, free for personal and research use forever. Next: drop-in adapters for SWE-agent, OpenHands, and Claude Code hooks, so memory is attached with zero code. Sustainable layer: a hosted team graph on InsForge — one shared procedural memory across every agent and engineer in an org, with cross-agent sync. The cloud persistence path is already wired: sync_insforge.py pushes the graph to InsForge tables (schema in migrations/), so the hosted version is a product decision away, not a rewrite. The open core stays open; teams pay for the shared brain, not the algorithm.

Use it in your own agent — one pip install

Install
pip install git+https://github.com/xqscora/cogram.git
Two lines in your agent loop
import memory_api
hits = memory_api.recommend(task)  # start of turn
memory_api.end_turn()              # end of turn: learn + tick

Where this is strong, where it isn't

Pros
  • Graph is built with zero LLM calls — co-occurrence + a novelty/surprise signal, not a model summarizing anything. Can't hallucinate a memory that never happened.
  • Forgetting has a floor, not a cliff — edges decay toward ε but are never deleted, and get re-lit the moment they're relevant again.
  • Decay runs on ticks (real interactions), not wall-clock days — an idle agent's memory doesn't erode just because time passed.
  • Every recall points to an exact file:line in the original transcript — never a generated summary, always checkable.
  • ~4.5× smaller on disk than raw transcripts; ~150–400 tokens per recall vs. thousands to replay full history.
  • Routing is measured, not cherry-picked: 43.3% top-1 same-repo recall vs. 2.9% chance (~15×) on 150 sampled bug reports, zero LLM calls — see benchmark_procedural_precision_results.md.
Cons — said plainly
  • Not the first zero-LLM concept-graph memory — SPRIG (arXiv:2602.23372) and MemGraph-agent already proved this general approach works.
  • On LongMemEval, our graph's ranking ties the best lexical baseline (BM25) rather than beating it outright — see appendix below.
  • It can only recall what the agent actually lived through — no prior trajectory, no memory of it.
  • "Concept-of-concepts" (promoting a whole bug→fix pattern into one reusable node) is designed but not yet implemented — see CONCEPT_OF_CONCEPTS.md.
  • Directed "next" transitions are a first-order heuristic, not yet validated against a dedicated procedural-accuracy benchmark.