Local-first  ·  Cross-tool  ·  Built for developers

Recover the reasoning behind everything you build with AI.

Tokenome is a private, searchable memory across every AI you use. It captures your conversations, indexes them on your machine, and traces any line of code back to the conversation that produced it.

Get started Watch the demo 30s

Nothing leaves your machine. No account. No cloud embeddings.

46%of new code is AI-assisted, heading to 60% this year
0 bytesof your conversations leave the machine
~41mshybrid BM25 and vector search over your whole history

The problem

Your AI conversations vanish

01

Knowledge evaporates

You solved this exact problem with an AI two weeks ago, and there is no way to find that thread again. Every tool is a walled silo.

02

The "why" is lost

AI now writes much of the code. git blame shows a commit message, never the conversation where the decision was actually made.

03

Nothing is shared

On a team, each person's AI work stays trapped on their own machine. Onboarding and review lose the context entirely.

How it works

Capture to recall, on your machine

Five stages, all local. Incremental by design: only new or changed turns are re-embedded, so a live session costs about one turn of work per poll.

  1. CaptureAuto-discover and poll your AI tools
  2. SegmentSplit threads into question and answer documents
  3. EmbedOn-device ONNX vectors, no GPU, no cloud
  4. IndexTypesense: BM25 fused with vector similarity
  5. ServeCLI, web UI, and MCP for AI agents

Signature feature

git blame for the "why"

Point at any line of code. Tokenome blames it to learn when it was last edited, then surfaces the conversations from exactly that change.

As AI writes a larger share of every codebase, the reasoning behind it lives in throwaway chat logs. Tokenome makes that provenance permanent, searchable, and yours.

  • Answer "why is this function written this way" in one click
  • Read the conversation behind a change under review
  • Recover the tradeoffs your commit message never kept
ledger.py
41def post_entry(tx, amount, key):
42 # idempotency lives here, not in retry
43 if ledger.seen(key):
44 return ledger.get(key)
45 entry = tx.write(amount, key)
46 metrics.emit("ledger.post", tenant=tx.tenant)
47 return entry

Hover a highlighted line

claude-code2026-06-14 · payments-api

Why is the retry wrapper double-posting on timeout?

Because the wrapper retries before the ledger write commits, so a slow commit looks like a failure and the second attempt writes again. Move the idempotency check into the ledger and let the client own backoff.

Edit tool call captured · ledger.py:42-44

See it work

One command, from a line of code to the reasoning

A line is blamed, the edit is located, and the conversation that produced it comes back. Thirty seconds, no cuts.

Real output from a real index. The repository and transcripts are sample data; the software is not.

And the agent can ask too

Through the MCP server, Claude queries the same memory while it works. Here it is talking a developer out of reintroducing a bug that was settled three months earlier.

A real claude -p session against the Tokenome MCP server. Eight turns, 27.5 seconds, no network calls out of the machine.

Access

Three ways in

For developers

Command line

Fast search from your terminal. Filter by platform, model, project or date. JSON output for scripting.

tokenome search "type hints" --since 30d

For everyone

Web UI

Search, browse by tool, timeline view, a full conversation reader, and the code-context finder. A local dark-mode app.

uv run tokenome app → localhost:8420

For AI agents

MCP server

Your AI queries its own past. Claude Desktop and Claude Code call search_memory and find_related directly.

tokenome mcp → stdio

What it captures

Cross-tool by design

Pick the AI you use. Tokenome finds where its conversations live. No paths to configure.

Claude Code

CLI transcripts, auto-discovered and polled. Tool actions (edits, commands, searches) captured too.

Claude Desktop

Fetched via the API, plus Cowork output files with git-blame metadata.

ChatGPT

Drop an exported conversations.json and it is indexed automatically.

Gemini and generic

Flat-JSON exports via a drop folder, plus a pluggable adapter for any new tool.

Capabilities

What is under the hood

Hybrid search

BM25 keyword plus on-device vector similarity, fused for precision.

Cross-tool recall

One index across every AI you use. No walled gardens.

Local and private

On-device embeddings. Your conversations never leave the machine.

Incremental ingest

Only new or changed turns re-embed. Clear-all is lossless.

Tool-action capture

Edits, commands and searches are indexed, not just chat.

Rich filters

Slice by platform, model, project and time range.

Python + uvTypesensefastembed / ONNX FastAPIMCPDeterministic IDs200+ tests

Positioning

Why it is different

Durable

Cross-tool

The platforms will only ever remember their own chats. Tokenome unifies across Claude, ChatGPT, Gemini and more. No vendor will do that for you.

Trusted

Local and private

On-device embeddings, nothing phones home. A real answer for anyone who cannot ship their work into a vendor's cloud.

The wedge

Code provenance

Blame-to-conversation is genuinely novel, and it grows more valuable every month as AI writes a larger share of all code.

Where it is going

Roadmap

Richer memory

Topic clustering and per-conversation summaries. Multi-resolution recall for both people and AIs.

Wider capture

A browser extension for claude.ai, ChatGPT and Gemini. Live capture where most conversations actually happen.

Team and distribution

Frictionless install, optional encrypted sync, and shared team memory. The path from tool to product.

Team

Team Tokenome

Start with one command

Pick your AIs, and start searching.

uv run tokenome app

Local-first  ·  Cross-tool  ·  Searchable  ·  Yours