Open-source project by Omniveer

GraphKeeper

Memory for coding agents you can inspect.

Durable knowledge stays beside the code, points back to evidence and the run that produced it, and is explicitly superseded when reality changes.

Current stable releasev0.5.0MIT licensed
Active repository memory provenance intact
Claimauth_locationsrc/auth/session.ts
Evidenceauth-location.logL1–L3
Producing runauth migration auditpassed
The stale-memory problem

Stale memory is worse than no memory.

Forgetting slows an agent down. Remembering an obsolete repository fact—and treating it as current truth—can send the next session confidently in the wrong direction.

Untraceable recallstale context survives
  1. Session 01“Authentication lives in src/legacy-auth.ts.”
  2. Repository changesAuth moves to src/auth/session.ts.
  3. Session 14The old location is retrieved without proof.

Confident answer. Unknown source. Outdated truth.

With GraphKeeperhistory stays inspectable
  1. RetrieveThe active claim arrives with evidence and run provenance.
  2. VerifyThe current file state contradicts the earlier claim.
  3. CorrectA new claim supersedes the old one; both remain reviewable.

Bounded verification. Explicit correction. Preserved history.

Claim → Evidence → Run → Git history → Retrieval → Verify or supersede

The 10-second picture

Memory with a paper trail.

Every useful discovery follows the same small loop: capture what happened, ground it, store it beside the code, and check it again when reality moves.

Installation & setup

From zero to your first grounded finding.

Node.js 18+, npm, and Git are all you need. GraphKeeper works on Linux, macOS, Windows through Git Bash or WSL, and current native Windows PowerShell.

01 / Install

Run GraphKeeper from your repository root.

npx graphkeeper@latest init --integrate codex

Use --integrate claude, another adapter, or --integrate all for your setup.

02 / Initialize

Review the plan and confirm it.

npx graphkeeper@latest check

init scaffolds graph/, evidence/, the validator, hook, skill, and agent guidance.

03 / Use

Ask your coding agent to record a verified finding.

$graphkeeper · /graphkeeper · @graphkeeper

The agent captures evidence, then appends the run and grounded claim safely.

04 / Verify

Retrieve the active knowledge in the next session.

npx graphkeeper query <subject>

Run doctor when you need physical evidence and cited line ranges checked too.

CLI reference

Every command you need after setup.

graphkeeper --help
graphkeeper initScaffold the graph and optionally install agent adapters.
graphkeeper integrate remove <adapter>Remove recognizable GraphKeeper-owned files for one adapter.
graphkeeper checkValidate schema, provenance, append-only history, and committed evidence.
graphkeeper query <subject>Print active claims and provenance for an exact ID or unique alias.
graphkeeper doctorCheck evidence files, containment, cited lines, dangling references, and unused entities.
graphkeeper append run ...Safely create the run record behind a finding.
graphkeeper append claim ...Safely append and link an evidence-backed claim.
graphkeeper updateInstall one exact newer stable version globally; repository files stay untouched.
graphkeeper --help / --versionShow supported options or the installed CLI version.

When check passes, commit the generated graph, validator, agent skill, and guidance file with your repository.

The trust model

Agent memory shouldn't just remember more.

It should be able to defend what it remembers.

Why does the agent believe this?

The claim carries a source instead of asking you to trust a summary.

What evidence supports it?

Tool output points to exact, line-addressable evidence stored in the repository.

Which run produced it?

The claim and its producing run reference one another, preserving provenance in both directions.

Is it still current?

A later session retrieves the active claim, inspects its provenance, and verifies only the state that may have changed.

What replaced it?

A successor points back with supersedes, making the correction explicit.

Can I inspect the correction history?

The old claim and evidence remain in Git instead of disappearing behind an overwritten note.

Knowledge you can inspect

Correction without erasure.

GraphKeeper stores flat claims. A tool-output claim cites exact evidence, points to the run that produced it, and can be replaced only by appending a successor.

Superseded claimclaim_1a2b3c4d
subject
repository_auth
predicate
auth_location
object
src/legacy-auth.ts
source
tool_output
produced_by
run_2026-08-10-auth_a1
created
2026-08-10T09:15:22Z
Evidenceevidence/auth-location.log#L1-L3
Active correctionclaim_5e6f7a8b
subject
repository_auth
predicate
auth_location
object
src/auth/session.ts
source
tool_output
produced_by
run_2026-08-29-auth_b2
supersedes
claim_1a2b3c4d
created
2026-08-29T08:42:10Z
New evidenceevidence/auth-migration.log#L4-L7

Supersedes the older claim. It does not erase it.

Git-native architecture

Memory lives beside the code.

Entities, claims, runs, and evidence are ordinary repository files. They travel with the code and are reviewed with the same Git workflow.

  • No hosted memory service. The core workflow stays repository-local.
  • No separate database. Plain JSON and text remain the v1 source of truth.
  • No hidden state. Knowledge changes appear in the repository diff.
  • No vector index. GraphKeeper retrieves exact subjects and their active claims.

“Append-only” is enforced relative to committed Git history. It is reviewable integrity—not a claim of cryptographic immutability.

Coding-agent integrations

One memory contract. Nine agent environments.

v0.5.0 ships a closed, data-driven adapter registry. Each target receives the same vendor-neutral GraphKeeper skill and a small reminder in its guidance location.

01Codex--integrate codex
02Claude Code--integrate claude
03Cursor--integrate cursor
04OpenCode--integrate opencode
05Kilo Code--integrate kilo
06Windsurf--integrate windsurf
07Gemini CLI--integrate geminicli
08Kiro--integrate kiro
09Antigravity--integrate antigravity
Install every registered adapternpx graphkeeper@latest init --integrate all

Automatic invocation is benchmarked for Codex and Claude Code. The other seven adapters install documented vendor locations whose discovery behavior can change with the agent product version.

Multi-agent reliability

Two agents should not become one lost finding.

The real failure is a write race: two sessions read the same graph, append different findings, and the later file replacement silently drops the first.

Create a run safelygraphkeeper append run
Append and link a claimgraphkeeper append claim

v0.5.0 serializes supported claim/run graph-file mutations so concurrent sessions do not silently overwrite one another. It does not claim distributed transactions.

  • v0.5.0Current stable release
  • TypeScriptCLI implementation
  • MIT licensedOpen-source project
  • 9 adaptersRepository integration targets
Open source. Repository local. Inspectable.

Give your coding agent memory it can defend.

Start with one repository and one agent. The memory stays with the code, and every durable claim has a path back to why it exists.

Run from your repository root
npx graphkeeper@latest init --integrate codex