AI agents forget. Notes scatter. One memory that remembers why.
The pieces sit in meeting notes, a support thread, a ticket, and whatever your agents wrote down. ReasonGraph joins them and answers the triage questions: why did this happen, and what did this change affect.
One memory for every source that writes something down — a person's notes as readily as an agent's. It stores each as a plain sentence, links them by the names they share and by what caused what, reasons over them backwards to causes and forwards to effects, and puts exactly what the next reply needs in front of your model, inside its context window. Every answer comes with the facts it used and where each came from. Small open models on servers we run, in the EU by default or the region you need.
MIT library. Hosted service from €0. Python, JavaScript, LangChain, LangGraph and MCP.
Northwind cancelled because their invoices went to an old address after the billing move, the unpaid invoices got their account suspended, and their complaint was never answered before the suspension.
How this answer was builtAfter the billing system move in June, Northwind's invoices were sent to their old office address.
root cause · financeBecause two invoices went unpaid, Northwind's account was suspended on 14 August.
billingNorthwind cancelled their contract on 20 August, citing the suspension.
salesFinance, billing and sales each wrote one sentence at different times. Nobody wrote the answer.
One question, one answer, and where it came from
Three agents each wrote one note, at different times, in different repositories. Nobody wrote the answer.
How this answer was built
- repo: search Because Elasticsearch rebuilds its index at 09:00 every day, the node's CPU is saturated for twenty minutes each morning.
- repo: infra Redis runs on the same node as Elasticsearch.
- repo: shop The checkout service stores shopping carts in Redis since the March release.
cause: Elasticsearch rebuilds its index at 09:00 → the node's CPU is saturated
The agent working in shop never opened the other two repositories. The memory walked from the question through the names they share, and found the cause.
More worked examples, ready to run, in the console's starter topics.
Run a pilot on your own text
Every number on this page comes from our own evaluation set. The honest next step is one real use case, yours: a week, one team, support or operations or research. We will tell you plainly whether your notes contain the chains this is built to follow. Your data stays in a database we run, in the EU by default or the region you need, and the core is open source, so you are never locked in.
Where teams use this
Situations rather than industries, so you can recognise your own.
- Everything already lives in one place, written by one person or one agent. The advantage here is connecting several sources, so it never comes into play.
- You are expecting connectors. There is an API and a console today: your tooling pushes text, or you paste it. Nothing reads your Slack or your calendar by itself.
- You want document search. This is not a better way to find a passage in a PDF.
- You need the deepest root cause found reliably, every time. It surfaces the full chain on a minority of questions today; the facts and their sources come back either way.
For builders: three calls, any stack
Remember a fact, discover what connects, and chat with the relevant memory placed in front of the model automatically. LangChain and LangGraph in one import (pip install "reasongraph[langchain]": a memory class, a retriever, a remembering model, agent tools). JavaScript and TypeScript through a dependency-free client. No code at all: open the console, pick a topic or paste a document, and ask.
from reasongraph.client import MemoryClient # pip install reasongraph
mem = MemoryClient(api_key="rgm_...")
mem.remember("scout", "TSMC is building a chip fab in Phoenix, Arizona.")
mem.remember("scout", "Arizona declared a water emergency after a drought.")
mem.remember("analyst", "Apple depends on TSMC for its M-series processors.")
mem.discover("Why might Apple face shortages?", session="analyst")
# → paths through TSMC and Arizona, 2 of them from the scout's session
mem.chat([{"role": "user", "content": "Why might Apple face shortages?"}], session="analyst")
# → the reply and the facts it used, with their sources
import { Memory, memoryTools } from "reasongraph"; // npm install reasongraph
const mem = new Memory({ apiKey: process.env.REASONGRAPH_API_KEY });
await mem.remember("scout", "TSMC is building a chip fab in Phoenix, Arizona.");
const facts = await mem.discover("What could disrupt the Phoenix fab?");
// OpenAI-style tool definitions with executors attached: remember, recall, why
const tools = memoryTools(mem);
from reasongraph.integrations.langchain import ReasonGraphMemory
from reasongraph.loop import make_summarizer
memory = ReasonGraphMemory(target=mem, session="support-chat",
max_history_tokens=2000, keep_tail_tokens=800,
summarizer=make_summarizer(lambda m: llm.invoke(m).content))
seen = memory.load_memory_variables({"input": question})
seen["memory"] # the facts the graph connects to the question, with sources
seen["history"] # the conversation, folded: a rolling summary, then the newest turns
memory.save_context({"input": question}, {"output": reply})
curl -X POST https://memory.primaxiom.ai/sessions/scout/memory \
-H "Authorization: Bearer rgm_YOUR_KEY" -H "Content-Type: application/json" \
-d '{"text": "TSMC is building a chip fab in Phoenix, Arizona."}'
curl -X POST https://memory.primaxiom.ai/discover \
-H "Authorization: Bearer rgm_YOUR_KEY" -H "Content-Type: application/json" \
-d '{"query": "Why might Apple face shortages?", "session": "analyst"}'
# a long conversation, folded to a token budget; the turns stay in memory
curl -X POST https://memory.primaxiom.ai/chat \
-H "Authorization: Bearer rgm_YOUR_KEY" -H "Content-Type: application/json" \
-d '{"session": "analyst", "max_history_tokens": 2000,
"messages": [{"role": "user", "content": "Why might Apple face shortages?"}]}'
claude mcp add --transport http memory \ https://memory.primaxiom.ai/mcp \ --header "Authorization: Bearer rgm_YOUR_KEY" # Claude Code now has push_memory, query_memory, # discover_connections, trace_memory, what_if_memory …
What makes it different
A graph, not a pile of similar sentences
Small purpose-built models turn every sentence into the names it mentions and the causes it states. A question then walks those links across agents and sessions and comes back with the path it took, every step cited.
Knows what changed, and when
Correct a fact and the old one leaves default recall but stays for history. A new fact that contradicts an old one retires it rather than erasing it. Query as of any past date, trace a cause downstream, or ask what breaks if a fact were false.
Fits the context window
Each turn the model gets the facts that relate to the question, with sources, and the conversation folded to a token budget: the newest turns verbatim, the older ones as one rolling summary. Folding decides what the model sees and deletes nothing; a turn that left the window is still a fact and comes back when it is relevant.
Plain and portable
Facts are plain text you can export. The hosted service and the MIT library share one API, so you can move between them.
The models, and where your data goes
Everything that stores, links and finds your facts runs on servers we operate, on CPU, with small open models. Only chat and written answers use a large model from an outside provider, and only when you ask for them.
| Step | Model | Runs |
|---|---|---|
| Split text into facts | SaT sentence splitter (sat-3l-sm, 85 languages) | our servers |
| Find entities | GLiNER zero-shot tagger (gliner_small-v2.5, multilingual) | our servers |
| Find cause → effect | Our fine-tuned mDeBERTa span model (causal-span-pointer-v3, open weights, served as ONNX) with a small token-level MiniLM gate that keeps plain statements out of the causal graph | our servers |
| Search and rank | Multilingual MiniLM embeddings (paraphrase-multilingual-MiniLM-L12-v2) and an mMARCO cross-encoder reranker | our servers |
| Contradiction check | Our fine-tuned 1.7B judge (open weights, Qwen3 base) served with llama.cpp; a small pre-filter skips pairs that cannot conflict | our servers |
| Chat and written answers | Outside provider: currently gpt-oss-120b on Groq. Sent: your messages and the facts recalled for that question. Nothing is trained on it. We may add EU-hosted options. | Groq (US) |
How it works
Compared with a vector store
Show the comparison
| Vector memory | ReasonGraph | |
|---|---|---|
| Retrieval | Nearest neighbours of the query | Neighbours, then a walk over shared entities and causal edges |
| "How does X affect Y?" | Facts about X and facts about Y | The path from X to Y, each hop cited |
| Contradictions | Both versions returned | Corrections retire the old fact; optional check on write; history kept |
| Extraction | None, or an LLM call per write | Small models on our servers, no large model in the write path |
| Agents sharing memory | One collection, no sessions | A session per agent; cross-session paths flagged |
Questions
Is this a vector database?
It uses embeddings to find seeds, but the value is in what happens after: the walk over entities and causal links. You can run it on Postgres with pgvector or SQLite.
What counts as an entity?
People, organisations, places, events, products, software and services, as recognised by a zero-shot model. Names bridge sessions; generic phrases do not. Writing "Redis" or "Bulk Export" connects; "the cache" or "the feature" will not.
Do I need to write code?
No. The console has a chat: pick a starter topic or paste a document, teach it facts in plain words, and ask. The same memory is then available to your agents over MCP or HTTP.
Which languages?
English is best measured. German, Dutch, Spanish, French and Turkish work with the same models; the splitter, tagger, embeddings and reranker are all multilingual. Numbers per language are in the library README.
What does a request cost?
Nothing on the free plan up to 10,000 requests a month. Paid plans are flat monthly prices with higher limits; see pricing.
Can I export or leave?
Your facts are plain text; the API returns them as such. The library is MIT, so the same graph runs anywhere.
Who builds this?
PrimAxiom Labs, a small engineering company in the Netherlands. The founder has shipped AI systems for Klarna, Booking.com and ING and maintains the open-source library.
Give your agent a memory that connects the dots.
Free plan, 10,000 requests a month, no card.