thread-keeper

Name: thread-keeper
Author: po4erk91

by po4erk91version 0.13.1i★ –iRuns on your computer

Registry nameio.github.po4erk91/thread-keeper

Install

Overview

Description from the maker (original English)

Multi-agent shared brain across Claude, Codex, Antigravity, Gemini, Copilot, and VS Code.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Runs on your computer
Transport: stdio
Category: Other

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on your computer with your user’s permissions (files, network, apps).
The registry lists no key to fill in.

You need

PyPIPython’s uv installed (for the uvx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "thread-keeper": {
      "command": "uvx",
      "args": [
        "threadkeeper"
      ]
    }
  }
}

Run this in your terminal

claude mcp add thread-keeper -- uvx threadkeeper

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "thread-keeper": {
      "command": "uvx",
      "args": [
        "threadkeeper"
      ]
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "thread-keeper": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "threadkeeper"
      ]
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.

Your choice stays on this device in a cookie; no account needed.

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Runs on your computer; the tool list appears in your AI app after you install it.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 7, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account po4erk91, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
– Not applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
– Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
… Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints

Compared with others in Otheri

More stars than 0% of the other 32599 servers in this category
Published to the registry more recently than 13% of the other 32599 servers in this category
Basic checks equal to or better than 100% of the other 32599 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is thread-keeper safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

The registry does not list a required key, though some servers ask you to sign in on first use.

Does it run on my computer or in the cloud?

It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).

Is it still maintained?

The GitHub repo last changed –, and the latest version (0.13.1) reached the registry 5 months ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Python (uv) on your computer.

What can I use instead?

In the same category: Spec Driven Development, Remote Desktop Commander, Zendesk

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Spec Driven Development

by formulahendry

MCP Server that facilitates spec-driven development workflows, not just Vibe Coding.

Runs on your computer★ 440MITUpdated 14 months ago

Install

Remote Desktop Commander

by desktop-commander

Remote Desktop Commander: use files, terminal and processes on your own computers from any AI app.

Runs in the cloud★ 211Updated 2 days ago

Install

Zendesk

by pipeworx-io

Zendesk MCP Pack — tickets, users, organizations via OAuth.

Computer or cloudUpdated today

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

thread-keeper

Multi-agent shared brain across Claude Code/Desktop, Codex, Antigravity CLI (`agy`), Copilot, and VS Code. Cross-session memory, self-improving skill loops, and inter-agent signaling — one local MCP server turns parallel agent instances into a coordinated multi-agent system instead of N isolated chats.

Every connected client (Claude Code, Claude Desktop, Codex CLI + desktop, Antigravity CLI, Copilot, every MCP-aware VS Code extension) shares one SQLite store, one set of threads, one user model, and one learning loop that improves the skill library autonomously over time.

The brief format is dense — structural tags, opaque IDs, ~6 KB per session-start injection. Optimized for agent consumption, not human reading.

Why

Every agent CLI starts cold. Context dies at session boundaries. Skills you taught Claude don't transfer to Codex. Threads you closed in yesterday's Antigravity chat are invisible to today's Copilot. Parallel agent instances running the same task don't know about each other and duplicate work or step on each other's writes.

thread-keeper is the substrate underneath. Three things that together make it more than a memory store:

Collective memory — threads, notes, verbatim quotes, dialectic claims about you. Survives session, restart, CLI swap. One agent records, every other agent (any CLI) reads. The brief injected at session start gives a new agent everything the previous one knew.
Multi-agent coordination — spawn primitive launches child agents in parallel, each gets a self_cid + sees the same memory. broadcast / whisper / inbox / wait / ask / respond let concurrent sessions signal each other across CLIs. Parent / children / sibling agents become a coordinated swarm, not isolated chats.
Self-improving skill library — autonomous background loops (auto-review on thread close, shadow-review daemon, extract harvester, candidate-reviewer, weekly Curator, and a thread-janitor that auto-closes idle threads so abandoned work reaches the harvest path — closing is reversible, a note reopens a closed thread) materialize class-level skills as the agents work. Adapted to multi-CLI: SKILL.md is the primary write target and gets mirrored to every known/configured skills root simultaneously (~/.claude/skills/, ~/.codex/skills/, ~/.gemini/config/skills/ for Antigravity, existing ~/.agents/skills/, extra roots from THREADKEEPER_EXTRA_SKILLS_DIRS, and ~/.threadkeeper/skills/), with lessons.md as a fallback for CLIs without a native skills loader. A managed skill write reports success only after every mirror has the expected file set and hashes; ERR mirror_partial_failure keeps the canonical copy and names only the affected consumer plus relative file. Retry safely with skill_manage(action="reconcile", name=" ").

Foreground MCP servers also run a daily self-update check by default. Source checkouts fast-forward their tracked git branch and reinstall the editable package; PyPI/pipx/venv installs run pip install --upgrade in the current interpreter environment only after the latest PyPI release files have matching Integrity API provenance from the expected GitHub Trusted Publisher. Dirty or diverged git checkouts are skipped rather than overwritten. Restarts are gated on install/setup success plus a subprocess import smoke check, so a broken or unverified update is recorded but the current server keeps running. Interpreters without pip (uv-created or pipx venvs) install through uv pip install --python when uv is available. Upstream PyPI publishing is intentionally gated: green merge-to-main builds are auto-tagged, but every upload pauses for a human approval on the protected pypi GitHub Environment (a maintainer-signed annotated v* tag remains the manual override path), as described in docs/RELEASING.md.

They also run a twice-weekly installed-skill updater by default. It keeps all configured CLI skill roots in sync, adopts newer local copies installed into a non-primary root, and updates GitHub-backed skills when a tracked upstream source changes.

Quickstart

The shortest path — PyPI + pipx (recommended):

pipx install 'threadkeeper[semantic]' && thread-keeper-setup

thread-keeper-setup detects every CLI you have installed (Claude Code / Claude Desktop / Codex CLI + desktop / Antigravity CLI agy / Copilot / VS Code), registers the MCP server in each one's config, copies hooks to ~/.threadkeeper/hooks/, and writes a managed instructions block into each CLI's per-user instructions file (CLAUDE.md / AGENTS.md / copilot-instructions.md — Claude Desktop and VS Code have no global instructions file, so that step is skipped for them). The generated MCP entry pins imports to this configured installation, so an agent launched inside another thread-keeper checkout cannot load that checkout's unmerged code against the live memory database.

Restart your CLI of choice. Hook-capable clients inject a brief on the first message; hookless clients such as Codex and Antigravity CLI either follow the managed instructions block and call brief() / context() before answering, or — on hosts that support MCP resources — pull the brief as the read-only memory://brief resource the host attaches automatically (see MCP primitives).

The MCP initialization response also carries concise, static lifecycle guidance: load the brief/context, open/note/close substantive threads, prefer read-only resources for host-attached context, and use dry-run plus confirmation before destructive maintenance. Hooks and the managed files remain reinforcement for clients that do not surface server instructions.

Alternative installs

If you don't have pipx and don't want to install it:

# uv (Rust-fast Python tool runner) — no clone, single binary on PATH

uv tool install 'threadkeeper[semantic]' && thread-keeper-setup

Plain pip into a venv

python3 -m venv ~/.threadkeeper-venv ~/.threadkeeper-venv/bin/pip install 'threadkeeper[semantic]' ~/.threadkeeper-venv/bin/thread-keeper-setup

For development (editable install from a git checkout) or to track the bleeding edge:

# One-liner installer — clones to ~/thread-keeper, makes a venv,

editable-installs, wires every detected CLI. Idempotent — re-run to

update (it git-pulls + reinstalls).

curl -fsSL https://raw.githubusercontent.com/po4erk91/thread-keeper/main/install.sh | bash -s -- --semantic

Or fully manual

git clone https://github.com/po4erk91/thread-keeper ~/thread-keeper cd ~/thread-keeper && python3 -m venv .venv .venv/bin/pip install -e '.[semantic]' .venv/bin/thread-keeper-setup

To preview without writing anything:

thread-keeper-setup --dry-run

Multi-CLI integration

CLI	MCP config	Instructions file	Hooks	Transcripts ingested
Claude Code	`~/.claude.json` `mcpServers`	`~/.claude/CLAUDE.md`	`~/.claude/settings.json` `hooks`	`~/.claude/projects/*/.jsonl`
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json` `mcpServers` (macOS); `%APPDATA%\Claude\…` (Win); `~/.config/Claude/…` (Linux)	none (GUI-only)	not supported by the app	none — chats live in Electron IndexedDB
Codex (CLI + desktop)	`~/.codex/config.toml` `[mcp_servers]` (shared between CLI and `Codex.app`)	`~/.codex/AGENTS.md`	not supported	`~/.codex/sessions/*/rollout-.jsonl`
Antigravity CLI (`agy`)	`~/.gemini/config/mcp_config.json` `mcpServers`	`~/.gemini/config/AGENTS.md`	not wired yet	`~/.gemini/antigravity-cli/conversations/*.db` (sqlite/protobuf, read-only: user prompts and final answers)
Copilot	`~/.copilot/mcp-config.json` `mcpServers`	`~/.copilot/copilot-instructions.md`	`~/.copilot/hooks.json`	`~/.copilot/session-store.db` (sqlite)
VS Code	`~/Library/Application Support/Code/User/mcp.json` `servers` (macOS); `%APPDATA%\Code\User\mcp.json` (Win); `~/.config/Code/User/mcp.json` (Linux)	none (per-workspace only)	not supported	none — extensions own their history

Every CLI that produces parseable transcripts feeds the same dialog_messages table with a source tag, so dialog_search() finds matches regardless of where the conversation happened. Claude Desktop and the VS Code adapter are the exceptions — MCP registration only; their chats don't reach the table for now (Electron IndexedDB on the Claude Desktop side; per-extension stores on the VS Code side). Antigravity keeps one SQLite file per conversation with protobuf step payloads; thread-keeper opens it read-only (never creating WAL sidecars next to it) and keeps only user prompts and final model answers, skipping tool calls and thinking.

VS Code's user-level mcp.json is the central host that every MCP-aware VS Code extension consumes — GitHub Copilot Chat, the Anthropic Claude IDE plugin, the OpenAI Codex IDE plugin, Continue, Cline, … — so a single registration there reaches all of them at once.

Adding a new CLI = one file under threadkeeper/adapters/ implementing the CLIAdapter contract. See CONTRIBUTING.md.

Python MCP SDK surface

thread-keeper requires MCP Python SDK 2.3 or later (mcp>=2.3.0,<3). Its stable Skills and durable Tasks extensions use the MCP 2026-07-28 extension surface, while tools, resources, prompts, annotations, structured content, elicitation, and stdio continue to use the same MCPServer instance.

MCP primitives (tools, resources, prompts, Apps, elicitation)

MCP has three server primitives. thread-keeper uses all three, mapped to the read/act split, plus MCP elicitation for host-native confirmations:

Primitive	Control	What thread-keeper exposes	When to use
Tools	model-controlled (may act)	the full surface — `brief`, `note`, `spawn`, `search`, `curator_review`, `wikilink_health`, …	the agent decides to call them
Resources	application-controlled, read-only	`memory://brief`, `memory://context`, `memory://dashboard`, `memory://agent-status`	the host attaches/pulls them automatically; capable hosts may subscribe
Prompts	user-controlled templates	`review_recent_threads`, `run_library_curation`, `audit_threadkeeper`	the user runs them (Claude Code: `/mcp__thread-keeper__` )
MCP App	host-rendered, display-only	`open_dashboard` → `ui://thread-keeper/dashboard`	a host that advertises MCP Apps opens the sandboxed dashboard

Resources back the genuinely read-only memory views with the same render functions as the matching tools, so the content is identical — memory://brief is brief(), memory://context is context(), and so on. The win is for hookless CLIs: instead of depending on the agent *remembering* to call brief() (agents focused on their task often skip it), a resource lets the host surface memory as attachable / @-mentionable context through a mechanical channel. The brief resource renders lean and agent-status uses a cached snapshot, so an automatic host pull is side-effect-free.

search and dialog_search also return structured hits and resource_link blocks. Read a hit's resource_uri with resources/read to inspect its evidence without

Only the beginning is shown; read the rest in the repo

thread-keeper

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Otheri

Common questions

Alternatives

Spec Driven Development

Remote Desktop Commander

Zendesk

README from the maker

thread-keeper

Why

Quickstart

Alternative installs

Plain pip into a venv

editable-installs, wires every detected CLI. Idempotent — re-run to

update (it git-pulls + reinstalls).

Or fully manual

Multi-CLI integration

Python MCP SDK surface

MCP primitives (tools, resources, prompts, Apps, elicitation)