The product, in six beats

What happens inside a memory that holds up.

The scene follows a public demonstration corpus, measured on the real demo: notes, links, a recall, a break, a review, a score.

The graph 38 notes · 60 edges

project rule reference us broken link

01 — The notes

One fact per file, and nothing else.

Every node is a markdown file: a description that works as a hook, a body, a date. Colour says the type — a project, a rule learned, a reference, or who you are. Size says the weight in words.

The 38 notes on screen are the Mirabeau Conseil demonstration corpus, a fictional firm: a two-partner organisational consultancy in French-speaking Switzerland, with its clients, its engagements, its methods, its tools and its traps. Fourteen families, 5,253 words — the size of a company's memory after a few months.

02 — The links

Knowledge is only useful once connected.

A [[link]] inside a note creates a synapse. “Closing an engagement properly” pulls on the one-page debrief, on “how we write”, on the GDPR/nFADP rule and on referrals: four edges from a single note, and the rest unfolds from there.

70 links in the corpus, 60 strokes on screen: a note and its engagement citing each other make one synapse, not two. The pulses travelling the edges are recall at work — semantic search starts from one note and spreads to its neighbours.

03 — The recall

On every turn, before the agent answers.

The question goes into the memory, and the notes that answer it land in the agent's context — without the agent having to think of searching. Here, “how do we wrap up a mission?” brings up 4 notes, ranked by a score that blends meaning and words.

This is the demo's real search, taken on 05.10.2026. The question is in English; the notes it brings up are written in French: recall is cross-lingual.

04 — The break

A note gets renamed. The link never hears about it.

The debrief template used to be called modele-restitution-2025. It was renamed in September, once there stopped being one per year. The note methode-restitution-en-une-page still cites the old name: the link points at a target that no longer exists, raises no error, and simply makes the session slightly more stupid.

Found, not staged. This broken link really is in the corpus: the review is what flagged it, and it costs six points of score. Open the public endpoint — it is there.

05 — The review

Every hour, the memory reads itself back.

Each check matches a failure already lived through on a real corpus. Two fire here: the broken link, and 3 notes outside the graph. Flagged notes stay lit, the others go dark.

broken_linksA [[link]] with no note on the other endwarn
orphansOutside the graph: findable by search onlyinfo
no_descriptionNo hook — the note will never surfacecrit
secretsA string that looks like a key (never displayed)crit
dead_pathsA quoted path that no longer exists in the repoinfo
stale_openWork in progress, untouched for over 60 dayswarn
near_duplicatesTwo notes at cosine ≥ 0.86 — merge theminfo

Seven of the twenty-five checks. The others watch the chain itself — MCP server unreachable, embedding model down, index out of sync or lagging.

06 — The score

One number, and what holds it back.

92 / 100

2 findings · 0 critical
1 broken link · 3 orphans

Score = 100 minus the sum of severity weights, damped by the logarithm of the number of occurrences. It does not reward volume: it penalises entropy. The corpus went from 14 to 38 notes without losing a point — then lost six on one broken link.

Read on 05.10.2026 at 10:13 UTC from demo.corthexis.com/api/review, a public endpoint.
Corpus: 38 notes · 5,253 words · 14 families · 70 links · 1 broken.

What it is not

Not a better RAG. A memory that does not rot in silence.

Storing and retrieving, others do well — Mem0, Zep, Letta, and the RAG of your framework. CortHeXis starts from the next question: how do you know that what the agent retrieves is still there, still true, and still found?

Memory fails quietly

An MCP server dropped from a config, an index too large for the context, a link to a renamed note: the agent does not crash, it just gets worse. The review re-reads the whole chain every hour and says so.

Files, not a black box

A note is a markdown file a person can read and fix, with a date and where that date comes from. The index is rebuilt from them at any time; no fact lives only in a database.

Measured, not promised

Recall is scored on your own questions, and a model change that lowers it is blocked. Our figures are published with their method — and their limits.

Capabilities

Six capabilities, one promise: a memory that stays true.

Each capability was born from a failure we lived through on a real working memory. All of them are in the public repository, and the same code runs on our memory and on the demo.

01
Recall on every turn
A hook injects the relevant notes before every answer, not only when the session starts: the agent that knew at the first message still knows at the fifteenth. The same recall reaches the sub-agents it launches — that is where it used to get lost.
In the repositoryRunning on our side

Where the recall lands
Session startinjected

Every following messageinjected

Sub-agents launched by the agentinjected
02
A review that detects and repairs
Every hour, twenty-five checks born from real failures: broken links, notes with no hook, forgotten work in progress, secrets in clear text, duplicates, a description that contradicts the body, an unreachable MCP server, a lagging index. Naming is repaired at indexing, losslessly; the rest — links to reattach, notes to merge, projects to close — comes as a proposal with its diff, applied only once you approve.
In the repositoryRunning on our sideLive demo

Demo review, 05.10.2026
broken_links1 finding

orphans3 notes

checks25 · every hour

score92/100
03
Notes that tell the truth: dates and provenance
Every recalled note arrives with its age and where its date comes from — written in the note, rebuilt by the indexer, or unknown. A bulk rewrite no longer makes the whole corpus look new, and a renamed note keeps its history.
In the repositoryRunning on our side

What the agent reads with the note
date written in the notereliable

date rebuilt at indexingday not guaranteed

no reliable traceunknown
04
Measured on your notes
A bench of questions whose right note is known — harvested from your sessions, written by hand or imported. A model or a setting only changes if recall does not regress, with the number to show for it. The public demo shows its own: 60 questions anyone can rerun.
In the repositoryRunning on our sideLive demo

The bench, 03.10.2026
Questions with a known right note300

Right note first (light profile)73 %

Question languagesFR · EN · DE
05
Runs anywhere, from a small server to a GPU
A light profile for a 4-core machine with no GPU, a GPU profile that adds a second ranking stage. Same code, same note format; the profile is chosen for the machine, and a change is measured before it is applied.
In the repositoryRunning on our side

Measured recall (MRR) per profile
Light · 4-core CPU, no GPU0.82

GPU · with reranking0.88

First generation0.55
06
Open source and sovereign
Apache-2.0, no account to create. Your notes stay as markdown files on your side and the model runs on your machine: after the first download, neither indexing nor recall needs to call anything outside.
In the repositoryRunning on our side

What you install
LicenceApache-2.0

Note formatmarkdown

Protocol to the agentMCP

Outbound calls to recallnone

In the public repository, version 2.0. Runs on our own working memory.

The proof

We don't say recall got better. We measure it.

300 questions whose right note is known, asked to our own working memory — 415 notes, 2,498 chunks, questions in French, English and German. Two numbers: does the right note come first, and at what rank on average (MRR: 1 = always first).

Right note first

42 % → 82 %

Engine, first generation42 %
Light profile · 4-core CPU, no GPU73 %
GPU profile · with reranking82 %

Average rank of the right note (MRR)

0.55 → 0.88

Engine, first generation0.55
Light profile · 4-core CPU, no GPU0.82
GPU profile · with reranking0.88

Where it is hard

52 questions have their answer only in the body of a note, never in its description. On those, the average rank goes from 0.42 to 0.73 on the light profile.

Why 300 questions

Our first bench, 35 questions, was saturated: the old engine already scored 0.91 on it. A bench that no longer separates anything proves nothing — so we widened it.

What it does not say

These 300 questions are written by us, on our corpus, which stays private. Yours will give a different number: the measurement runs on your notes with corthexis eval. And to check without taking our word for it, a public 60-question bench on the demo corpus, to rerun on your machine.

The numbers as a table

Configuration	First	MRR	MRR, answer in the body
Engine, first generation	42 %	0.55	0.42
Light profile · 4-core CPU, no GPU	73 %	0.82	0.73
GPU profile · with reranking	82 %	0.88	not measured

Measured on 2 and 3 October 2026 on the second generation of the engine, running on our memory since 3 October 2026. Light profile: 53 to 69 ms per query on 4 cores.

Get started

Standalone, in a few commands. Or inside SOKKAN.

Standalone

With your agent, over MCP

The public repository is the whole engine: recall at every turn and in sub-agents, search over MCP, review, repairs, dashboard and bench. Docker, four cores, no GPU required.

$ git clone https://github.com/ninabot-ch/corthexis && cd corthexis
$ ./setup.sh ~/.claude/projects/<projet>/memory
$ docker compose up -d
$ claude mcp add -s user --transport http corthexis http://localhost:8420/mcp …
$ python3 corthexis/hook.py install

The full guide on GitHub →

Built in

Inside SOKKAN, the cockpit

SOKKAN runs Claude Code sessions in parallel. Since SOKKAN 3.0, CortHeXis is its memory tab: the same engine, installed and wired for you, plus the cockpit that runs the agents.

$ curl -fsSL https://sokkan.ch/install.sh | sh

sokkan.ch →

The demo is open

Ask a real memory your own questions.

Fictional corpus — a consulting firm, 38 notes — but real engine, real search, real review. Graph, semantic constellation, age, health, and each note's panel. No account, no form.

Open the demo

Screenshot of demo.corthexis.com: a question asked in English, and the notes written in French that come up with their score. — Real screenshot of demo.corthexis.com, 3 October 2026 — question in English, notes in French.

Born in production

The engine came out of a real working memory.

417notes

442,330words

1,359commits

5 monthssince 19.04.2026

Written while actually running a company, not by filling a demo folder. This corpus is private and will not be published: it is full of infrastructure and customers. The engine is open — and the proof that matters is what happens when you run it on your notes.

Measured on 05.10.2026 against Ninabot Sàrl's repository.

Training

Would you rather learn the method live, on your own files? A six-session cohort exists, next to the product. See Training →

Memory for your agents that rereads itself, repairs itself, and proves it works.