Agent memory · plain text · MCP

AI memory you can read, diff and put in git.

Attelium gives your coding agent a long-term memory that lives in ordinary text files: a knowledge graph you can open in any editor, review in a pull request and roll back with git. No vector database. No black box.

Works with any MCP client. One command sets it up for Claude Code. Open source, MIT licensed.

An agent remembers something (memory/graph/facts/2026-11.kgl)
@Fact billing-service uses_database postgres
subject: "billing-service"
predicate: uses_database
object: "PostgreSQL 16, not MySQL: needs row-level
  locking for invoice runs"
updated: 2026-11-18T09:42:10
[about] → entities/objects/billing-service.kgl#billing-service
Next week, in code review
$ git diff --stat memory/
 memory/graph/facts/2026-11.kgl          | 14 +++++++++++++-
 memory/graph/preferences/adrian.kgl     |  3 +++
 memory/graph/entities/objects/billing…  |  6 ++++--

Your agent forgets. The usual fixes hide what it learned.

Most agent memory is an opaque store you can only query through the agent itself. You can't see what it decided to remember, you can't correct one wrong belief without re-embedding, and you can't review changes the way you review code.

Can you see it?

Open the folder. Every memory is a node in a text file, with fields, tags and typed links to other nodes.

Can you review it?

Memory changes are ordinary diffs. Check them in a pull request, blame a line, revert a bad day with one command.

Can you fix it?

A wrong fact is a wrong line. Edit it, or ask the agent to delete_memory. No index to rebuild by hand.

How it works

Attelium is an MCP server over a folder of KGL files. The agent writes through typed tools and recalls through one call.

01 · WRITE

The agent takes notes

While it works, the agent calls add_fact, add_entity, record_preference and link_entities to save decisions, conventions, bugs and preferences, with links between related things.

02 · STORE

Plain files in your repo

Everything lands as .kgl text under memory/graph/: sessions, entities, facts, preferences, reasoning. Your repo, your history, your backups.

03 · RECALL

One call brings context back

get_context runs hybrid search, follows one hop of links from each hit and adds recent messages, packed into a token budget.

Plain text vs a black-box memory

Different tools for different jobs. Attelium is built for the memory of a person or a project, where being able to inspect and correct it matters most.

Attelium (plain-text graph)Typical vector-store memory
InspectOpen the files, or the built-in viewerQuery the index through code or the agent
Review changesgit diff, pull requests, blameRarely diffable
Correct a mistakeEdit one line, or delete_memoryDelete and re-embed
RelationshipsFirst-class typed links, one-hop expansionSimilarity only, unless you add a graph
Runs offlineYes. Local search; optional local model (one-time download)Often needs an embeddings API
ScaleOne person's or one project's memory (thousands of nodes)Built for very large corpora

Read the honest version, including when you should not use this →

Batteries included

Graph viewer

A read-only web dashboard: pan-and-zoom graph, recent activity, sessions, search, lint warnings and the agent's own search log.

Hybrid search

Zero-dependency lexical search by default. Add one extra for real semantic matching with a small local model. Your memory never leaves your machine.

Reasoning traces

Record why a decision was made and which memories informed it, so the next session finds the reasoning, not only the facts.

Stop-hook nudge

For Claude Code, kgl-memory-init can add a hook that reminds the agent to save notes when a turn changed code but wrote no memory.

Maintenance tools

An offline duplicate scan and an optional reflection pass that synthesises higher-level insights. Nothing is merged or written without you.

Per-project memory

Each project gets its own graph, registered with an absolute path, so memories never leak between unrelated work.

The pieces

Attelium is the product. The parts are separate and open, so you can use any of them on their own.

Attelium product

The front door: docs, quickstart and the memory server setup. kgl-memory is the package and MCP server.

KGL open format

The plain-text knowledge-graph file format and its parser, linter and query engine (pip install kgl-lang).

Graxeon editor

A workspace for browsing and editing KGL graphs, with spreadsheet-style editing and a live graph preview.

Unfoldata services

Want it set up for your team's repos and workflows? Get in touch.

Built because it was needed

Attelium's memory runs on the author's own projects. Building it against KGL's write layer turned up six real bugs in that layer, all fixed before kgl 0.2 shipped. It is alpha software: the format and tools are stable enough to use, and still changing.

On the roadmap planned, not available yet

  • Starter memory packs (personal assistant, project memory, research notes).
  • Hosted sync and shared team memory.
  • A listing in the MCP server directories.

Give your agent a memory you can actually read.

Five minutes from install to your first remembered fact.