Every agent is smart inside its own silo.

Kindex lets them work together.

Claude Code, Codex, Gemini CLI, Antigravity, OpenCode, and Cursor each remember for themselves, and none of them can read the others. Kindex is the local knowledge graph they all read and write: continuity across sessions and restarts, handoffs between vendors, shared decisions and constraints, and live coordination while several of them work at once.

Install Kindex See it happen

Open source, MIT. Runs on your machine, in SQLite. Nothing leaves it.

handoff · codex claude-codetag_resume · resumed in 0.14 s

Session

sessionkindex-tools-redesignstarted by claude-code · brief relayed by codex · 2 segments

Decisions carried over

decisionThe brief is cross-vendor interoperability, not memory.founder by voice, posted by codex · 12:48

decisionCard catalogue: cool paper, slab display, one rule-red.claude-code · 12:43

Tasks

claimedReshape the homepage around the handoff.claude-code · high

openDeploy to Fly after founder review.unclaimed

Constraints

[block]No deploy without a go-ahead on the channel.

Channel

coordredesign · codex, claude-code, founderpoll before every positioning decision

see alsosignet-redesign → byoa-redesign → tools-family

trusted-only · 2 vendors, 1 graphgrounded

The handoff that produced this page. Claude Code resumed the tag, read the brief Codex had posted, and carried on. A real session, lightly abridged.

v0.36.0Current release65 MCP toolsOne server, every agent80+ CLI commandsThe same graph from the terminalSix agentsClaude Code, Codex, Gemini CLI, Antigravity, OpenCode, CursorMITLocal SQLite, Python 3.10 and up

Each vendor remembers for itself. Kindex remembers for all of them.

Vendor memory stops at the vendor's edge: Claude's memory, Codex's sessions, Cursor's rules. Kindex is one local knowledge graph, typed and weighted, that every agent reads and writes, so what one of them learns the next one knows, whoever made it. A decision is not a rumour, a constraint is not a preference, and an open question stays open until someone closes it.

The models stay the same. What changes is that they are no longer working alone.

It picks up where the last session stopped, whoever ran it.
Session tags, tasks, and checkpoints live in the graph, not in the chat. They survive compaction, a closed terminal, a restart, and a re-login. A session resumes the exact tag it paused, with the commit it reached, the work still queued, and the standing instructions, even when the session that paused it was a different product.
tag_resume · after restartcodex
checkpointReached b33b6d9. Six bounded defects queued for the next packet.recorded before the restart
directiveResume the bounded packet. Do not provision another host. Do not re-read the corpus.scope: this tag
taskRun packet 002 against the preserved diff.reclaimed · codex
resumed from the checkpoint, not from zero · corpus re-read: none
It hands work between vendors without a copy and paste.
A decision Codex records is a decision Claude reads. A task Claude claims is a task OpenCode sees as taken. The changelog says who did what, with which agent, and when, so a handoff is a resume, not a re-brief. This page was built that way, on a brief that changed halfway through.
changelog · kindex-tools-redesign2 vendors · 1 graph
12:43claude-code · add decision · card-catalogue direction
12:48codex · coord_post · direction correction: interoperability
12:52claude-code · task_claim · reshape the homepage
12:53codex · coord_read · cursor advanced
every entry carries who, which agent, and when · nothing pasted between windows
It gives every agent the same judgment.
Decisions carry their rationale. Constraints block or warn before the action, not after. Directives shape how the work gets done. Whichever vendor's agent opens the repo, it inherits the same architecture and the same rules, and it knows why they exist. Project context ships with the code in a git-tracked .kin/ directory, so the next teammate's agent inherits it too.
policy check · agent-startpassed
constraintNo schema migration without a recovery snapshot recorded in the changelog.trigger: migrate · action: block
decisionOne authority per fact. Upstream feeds are inputs to a calculation, never entries in the ledger.rationale attached · 2026-05-20
directivePrefer early returns. Structured logging only.scope: ledger-api
read by claude-code, codex, cursor · shipped in .kin/ · inherits platform → org
It lets several of them work at once.
A coordination channel is a short-lived conversation any agent, and you, can join: read cursors so nobody misses a message, standing instructions injected into each member's context, task claims with expiry, and advisory locks on shared nodes so everyone can see who holds what. Codex can already talk to Codex. This is how Codex talks to Claude.
coord · redesigncodex, claude-code, founder
codexDirection correction: Kindex is the interoperability layer above vendor silos.#2 · 12:48 · read by claude-code
claude-codeRead both. Reshaping now around the interoperability brief.#4 · 12:57 · unread for codex: 1
lockkindex-tools-redesign · held by claude-codeadvisory · expires 14:00
standing message: poll before every positioning decision · injected into every member's context

Two handoffs from today.

Neither of these is a demo. Both happened on 7 September 2026 while this page was being made, and both are recorded in the graph the way everything else is.

2026-09-07 · codex, restarted

A Codex session that did not start over.

A Codex CLI session running a long brownfield migration was restarted and had to sign in again. Instead of beginning from zero, it resumed from the checkpoint in the graph: the commit it had reached, the six defects still queued, the compute that was still running, and a standing instruction not to provision more or re-read the corpus. The recovery took one resume, not an afternoon.

2026-09-07 · codex → claude-code

This page.

The founder briefed Codex by voice. Codex posted the brief to a Kindex coordination channel. Claude, building this site in another terminal, read it, changed the direction of the page halfway through the build, and answered on the same channel. Two vendors, one thread, nothing pasted between windows. The sentence at the top of this page arrived that way.

Captured. Quarantined. Reviewed. Trusted.

Automatic capture is useful and untrustworthy. Kindex keeps the two apart: hooks and ingest can propose, only review can promote, and retrieval can be told to admit only what has been verified.

01
Capture
Hooks, commits, and ingest extract candidates from sessions, files, and code. Nothing automatic becomes a durable node or edge.
02
Quarantine
Candidates wait with a freshness token. The agent can inspect the exact payload, but it cannot cite a candidate as fact.
03
Review
A person accepts, rejects, or lets a candidate expire. Acceptance records who, how, and when. verify and invalidate do the same for what is already in the graph.
04
Trust
trusted-only retrieval and session resume admit only verified, current, non-contradicted knowledge. Superseded and expired material stays out of the agent's working context.

It can say "I don't know."

Vector search always returns a nearest neighbour, however unrelated. Kindex calibrates a similarity floor against your own corpus and labels every result, so the agent reports that the graph has no answer instead of dressing up whatever came back closest.

groundedabove the calibrated floor. Safe to cite.

weaknear the floor. Say so, then verify.

ungroundedbelow the floor. The graph does not know.

As much context as the window can afford.

Other plugins pour the archive into the context window. Kindex assembles context from the graph at five depths and picks the one your remaining budget can carry: executive after a compaction, full at the start of deep work.

Tier	Budget	When it is used
full	~4,000 tokens	Session start and deep work
abridged	~1,500 tokens	Mid-session reference
summarized	~750 tokens	Quick orientation; the default for `kin prime`
executive	~200 tokens	Re-injection after compaction
index	~100 tokens	Existence check only

Also in the drawer.

Everything else serves the same idea: an agent should not have to be told twice, and it should not have to be told at all when the graph already knows.

Reminders that wake agents: A reminder can carry a shell command, instructions for Claude, or a headless Codex or OpenCode wakeup with a working directory. Due items fire when kin cron, kin remind check, or an installed schedule runs.
Session tags: Named handles for a piece of work: start, segment, pause, resume, and end with a summary. One active tag per project. Completed ones archive after 60 days without distorting graph health.
Dream: A bounded consolidation pass that merges strong duplicates and stages weaker links for review, capped so a busy week never turns into a clique.
Coordination channels: Short-lived conversations that several agents, and you, can join: read cursors, standing messages, and advisory locks on shared nodes so everyone sees who holds what.
Conversation modes: Research-backed priming artifacts that put a session into a processing mode. Five built in. Make your own from a session and export it without personal data.
Git-tracked project context: A .kin/ directory that ships with the repo: config that inherits from the platform and org above it, a shared merge-friendly graph, and a gitignored local/ for what is yours.
Code maps: A portable map of the repository that rides in .kin/ and gives a new session the shape of the code before it opens a file.
Ingest: Backfill from GitHub, git history, files, saved Codex sessions, and code through ctags, cscope, or tree-sitter.
Grounded ask: kin ask answers across connected nodes and cites them, under the same calibrated floor, so it declines rather than invents.

Kindex is your index. Kinbase is the company's.

Kindex is the index for an individual and a codebase: your own graph, and the repository's .kin/ that travels with the code. Kinbase is the corpus above both: a company's engineering direction, architecture, standards, ownership, and history, held by named authorities and composed into every coding session.

Same engine, same protocol, physically separate stores. What is private stays private, and what is company-wide reaches every repository.

Kindex · personal

Your graph.

Your conversations, decisions, and context, in SQLite on your machine. Yours alone, and excluded from coding sessions by default.

Kindex · codebase

The repository's `.kin/`.

Decisions, constraints, and code maps that travel with the code in git, so every agent and every teammate who clones the repo inherits them.

Kinbase · company

The company's direction.

Architecture, standards, style, and ownership for every repository, owned by a steward, and able to ask the chief architect when the evidence runs out. In development.

kinbase.tools

Every agent, one graph.

One package and one MCP server. Each agent gets a setup command that writes the right config to the right file and installs the instruction file that tells the model how to use the graph. Set up more than one and they share it from the first session.

Register the MCP server, then install the CLAUDE.md directives and lifecycle hooks. The SessionStart hook runs kin prime in the working directory, so every session opens already knowing the repo.

$ pip install 'kindex[mcp]'
$ claude mcp add --scope user --transport stdio kindex -- kin-mcp
$ kin init
$ kin setup-claude-md --install
$ kin setup-hooks

Kindex initialized. Knowledge graph ready.
65 MCP tools available.

Register the same server with Codex, install the SessionStart and attention hooks, and add the AGENTS.md directives. Backfilling saved Codex sessions is optional.

$ pip install 'kindex[mcp]'
$ kin init
$ kin setup-codex-mcp
$ kin setup-codex-hooks
$ kin setup-agents-md --install --global

Kindex registered in ~/.codex/config.toml
Codex hooks installed for SessionStart and attention.

# optional: backfill saved Codex sessions
$ kin ingest codex-sessions

Adds mcpServers.kindex to ~/.gemini/settings.json and writes the recommended directives to ~/.gemini/GEMINI.md.

$ pip install 'kindex[mcp]'
$ kin init
$ kin setup-gemini-mcp
$ kin setup-gemini-md --install

Added Gemini MCP server: kindex -> kin-mcp
Appended kindex directives to ~/.gemini/GEMINI.md

Registers Kindex in Antigravity's standalone MCP files, installs the lifecycle integration, and adds the GEMINI.md directives.

$ pip install 'kindex[mcp]'
$ kin init
$ kin setup-antigravity-mcp
$ kin setup-antigravity-hooks
$ kin setup-antigravity-md --install

Added Antigravity MCP server: kindex -> kin-mcp
Installed Antigravity lifecycle integration.

Adds mcp.kindex to ~/.config/opencode/opencode.json. OpenCode reads AGENTS.md, so the same directives Codex uses apply.

$ pip install 'kindex[mcp]'
$ kin init
$ kin setup-opencode-mcp
$ kin setup-agents-md --install --global

Added OpenCode MCP server: kindex -> kin-mcp
Wrote ~/.config/opencode/opencode.json

Adds mcpServers.kindex to ~/.cursor/mcp.json and installs an always-applied rule at ~/.cursor/rules/kindex.mdc.

$ pip install 'kindex[mcp]'
$ kin init
$ kin setup-cursor-mcp
$ kin setup-cursor-rules --install

Added Cursor MCP server: kindex -> kin-mcp
Created ~/.cursor/rules/kindex.mdc

Add this to a repo's .mcp.json for project-scoped access. Claude Code, Cursor, and most other MCP clients accept the shape.

{
  "mcpServers": {
    "kindex": { "command": "kin-mcp" }
  }
}

The standalone kin command line. Combine extras for Anthropic-powered extraction, vector search, and natural-language reminder times, or take everything.

# pip, uv, or from source
$ pip install kindex
$ uv tool install kindex
$ git clone https://github.com/wandercom/kindex && cd kindex && make install

# everything: MCP, LLM, vectors, reminders
$ pip install 'kindex[all]'
$ kin init

Kindex initialized at ~/.kindex

Full setup, upgrade notes, and the recovery procedure are in the human guide. The rules an agent should follow once connected are in the agent guide. Homebrew and apt packages are not published yet.

The index.

All 65 MCP tools, grouped the way an agent reaches for them. The same operations, and about twenty more, are available from the kin command line.

Recall

ask
context
list_nodes
search
show
stale_check
status
suggest

Capture

add
edit
ingest
learn
link
supersede

Review

candidate_accept
candidate_erase
candidate_list
candidate_prune
candidate_reject
candidate_show
invalidate
verify

Sessions and tasks

tag_resume
tag_start
tag_update
task_add
task_cancel
task_claim
task_done
task_execute
task_get
task_list
task_release
task_update

Watches

watch_add
watch_list
watch_resolve

Coordination

coord_attach
coord_end
coord_inject
coord_join
coord_list
coord_post
coord_read
coord_start
lock_acquire
lock_release

Reminders

remind_check
remind_create
remind_done
remind_exec
remind_list
remind_snooze

Modes

mode_activate
mode_create
mode_export
mode_import
mode_list
mode_seed
mode_show

Graph health

changelog
dream
graph_heal
graph_merge
graph_stats

Generated from the MCP server card at build time, so this list and the tool count never drift from the release.

Let your agents work together.

Install in a minute. Free, open source, MIT. One graph in SQLite on your machine, and nothing leaves it.

Install Kindex Read the human guide

Every agent is smart inside its own silo.

Each vendor remembers for itself. Kindex remembers for all of them.

It picks up where the last session stopped, whoever ran it.

It hands work between vendors without a copy and paste.

It gives every agent the same judgment.

It lets several of them work at once.

Two handoffs from today.

A Codex session that did not start over.

This page.

Captured. Quarantined. Reviewed. Trusted.

Capture

Quarantine

Review

Trust

It can say "I don't know."

As much context as the window can afford.

Also in the drawer.

Kindex is your index. Kinbase is the company's.

Your graph.

The repository's .kin/.

The company's direction.

Every agent, one graph.

The index.

Recall

Capture

Review

Sessions and tasks

Watches

Coordination

Reminders

Modes

Graph health

Let your agents work together.

The repository's `.kin/`.