threadport
Early access · Local-first · BYO key

Carry your AI chat
into your IDE.

You think in ChatGPT or Claude. You ship in Cursor, Claude Desktop, Claude Code, or Windsurf. Threadport captures the thread and compresses it into a structured capsule — intent, decisions, assumptions, weak spots — then serves it to your IDE-side AI over MCP. No copy-paste.

Works with ChatGPT · Claude.ai → Cursor · Claude Desktop · Claude Code · Windsurf

01 · CAPTURE chatgpt.com
chatgpt.com/c/codex-osx
You Codex Computer Use crashes on macOS 14.4.1. Can't update. Fix?
ChatGPT The binary expects macOS 15+. SIP blocks patching. Best path is the OS upgrade…
You Storage is full and I can't free 25GB. What else?
ChatGPT …use Codex CLI without Computer Use, here's how…
02 · COMPRESS ~840 tokens
Codex Computer Use macOS 14.4.1
Intent Use Codex without OS upgrade.
Decisions Drop OS upgrade Codex CLI only
Weak spots SIP absolutism Storage untested
Next move npm i -g @openai/codex
Handoff → claude
03 · CONTINUE Claude Desktop
Continue from capsule
Use the ai-capsules tool to load my latest capsule and continue.
get_latest_capsule() approved · 12ms
Reading capsule. The prior thread treated SIP as absolute and the storage constraint as fixed — neither holds. Three real paths:
  • Codex CLI without Computer Use (matches your decision)
  • UTM/QEMU with macOS 15 guest (sidesteps SIP entirely)
  • External SSD boot for the upgrade (frees host storage)
Starting with #1 — running npm i -g @openai/codex
The gap

Your AI context dies between the browser and your IDE.

Every AI tool you use is its own island. Moving work between them costs you the only thing you can’t buy back — context.

01

Copy-paste tax

Selecting and re-pasting a 40-message thread breaks every time. You lose half the nuance and your wrist.

02

Re-explaining context

The next AI doesn’t know what you decided, what you rejected, or which assumptions the prior model relied on.

03

Weak spots get carried forward

Whatever the first AI got wrong rides into the next session unchallenged, because nobody flagged it.

04

Token budget waste

Pasting raw chats burns tokens. A structured capsule compresses 85–95% while keeping every decision and constraint.

How it works

Three steps. One bridge.

Threadport ships as a Chrome extension plus a tiny local MCP server. Both run on your machine. Capsules live at ~/.ai-capsules/capsules.json.

STEP 01

Capture

Open ChatGPT.com or Claude.ai, click the Threadport button. The extension reads the visible thread — never your tabs in the background, never your account.

runs only on chatgpt.com + claude.ai
STEP 02

Compress

A local LLM call extracts intent, context, decisions, assumptions, weak spots, open questions, and next actions into a compact capsule (~600–1,500 tokens).

85–95% smaller, 0% lost
STEP 03

Continue

Open Cursor, Claude Desktop, Claude Code, or Windsurf. Ask: “Use the ai-capsules tool to load my latest capsule.” Your IDE-side AI pulls it natively over MCP.

no copy-paste, no token waste
The capsule

What lives inside (and why it beats a transcript).

A capsule isn’t a summary. It’s a structured judgment object the next AI can reason against — not just read.

  • Intent Primary goal of the conversation, in your own words.
  • Context Important details — your machine, constraints, prior attempts, deadlines.
  • Decisions What you decided, with rationale. Even implicit ones.
  • Assumptions Both yours and the prior AI’s. High-risk ones tagged.
  • Weak spots Where the prior model overreached — accepted a constraint, framed something absolute, ignored an option.
  • Open questions Only the ones whose answer would change the next move.
  • Next actions Concrete steps — commands, decisions, validations.
  • Handoff target The model the capsule recommends continuing with.
capsule.json live in MCP
~/.ai-capsules/capsules.json
 1{
 2  "title": "Codex Computer Use macOS 14.4.1",
 3  "user_intent": {
 4    "primary_goal": "Use Codex on Mac without OS upgrade."
 5  },
 6  "decisions": [
 7    { "decision": "Drop OS-upgrade path" },
 8    { "decision": "Use Codex CLI w/o Computer Use" }
 9  ],
10  "weak_points": [
11    { "issue": "SIP framed as absolute blocker", "should_challenge": true },
12    { "issue": "Storage constraint not pressure-tested" }
13  ],
14  "next_actions": [
15    { "action": "npm i -g @openai/codex" }
16  ],
17  "recommended_handoff_target": "claude"
18}
JSON · UTF-8 · 17 lines read by ai-capsules MCP
Why MCP

The IDE-side AIs already speak this protocol. Threadport rides it.

MCP (Model Context Protocol) is the standard way AI assistants in Cursor, Claude Desktop, Claude Code, and Windsurf pull live data from your machine. Threadport ships a tiny local MCP server that exposes your capsules as tools the assistant can call.

Claude Desktop · Cursor · Windsurf
{
  "mcpServers": {
    "ai-capsules": {
      "command": "npx",
      "args": ["-y", "@ai-capsules/mcp-server"]
    }
  }
}
in your IDE
You: Use the ai-capsules tool to load my latest
     capsule, then continue from the next action.

Claude: Reading capsule "Codex Computer Use macOS 14.4.1"…
        Decisions: ✓ Drop the OS upgrade path
                   ✓ Use Codex CLI w/o Computer Use
        Next action: `npm i -g @openai/codex` and
                     wire into Cursor session.
        Weak spots: SIP-blocks-all-patching framed
                    absolutely; not actually true. …
Pricing

Free forever for power users. Pro for one-tap setup.

No accounts. No data resale. Capsules never leave your machine unless you opt into Pro hosted generation.

Free
$0/mo

Bring your own OpenRouter or OpenAI key. Local-only forever.

  • 10 captures / day
  • All extraction features
  • Full MCP delivery to any IDE
  • Capsules saved locally
  • No account required
Install from source
Lifetime
$49once

Pro forever, one payment. First 200 founders only.

  • Everything in Pro
  • Locked at $49 forever
  • Priority Discord access
  • Direct line to the founder
  • Vote on the roadmap
Reserve a Lifetime spot

Reservations open. No charge until Pro launches.

Get notified

Be first to know when Threadport ships.

One short email when the Chrome Web Store build is live, and again when hosted Pro opens. No drip campaigns. Unsubscribe in one click.

Or install from source todayview on GitHub.

Install

Chrome Web Store soon. Source today.

Store listing is in submission — one-click install when it ships. Until then, clone the repo, run the local server, load the extension, and paste one MCP block into Cursor or Claude Desktop.

{
  "mcpServers": {
    "ai-capsules": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/ai-capsules/mcp-server/dist/index.js"]
    }
  }
}
FAQ

Quick answers.

Where do my capsules live?
On your machine, in ~/.ai-capsules/capsules.json. The MCP server reads from that file. Nothing is uploaded unless you turn on Pro hosted generation, which only sends the chat content we need to extract a capsule and never persists it.
Why not just paste my chat into the next AI?
Pasting raw chats is lossy: the next AI gets a wall of text instead of structured judgment, and you burn 5–10× more tokens. Capsules are 85–95% smaller and preserve every decision and constraint as labeled fields the next AI can reason about.
What is MCP and why does it matter?
Model Context Protocol is the open spec Anthropic, Cursor, and others adopted for letting AI assistants pull live data from your machine — files, APIs, custom tools. Threadport runs a local MCP server that exposes your capsules as tools any MCP-compatible IDE can call. That’s why Cursor and Claude Desktop can read your capsule directly without copy-paste.
Which AI tools does Threadport support?
Capture: ChatGPT.com and Claude.ai at launch; Gemini and Perplexity in the next release. Delivery: any MCP client — including Cursor, Claude Desktop, Claude Code, and Windsurf.
Do I need an API key?
For the free tier: yes, an OpenRouter or OpenAI key. They cost ~$0.001 per capsule (Gemini Flash) and you control the spend. For Pro ($5/mo): no — we run the LLM for you.
Is my data sold or used to train models?
No. There is no analytics layer, no telemetry, no data sale. Read the source — the whole project is on GitHub.
Why “Threadport”?
Thread: an AI conversation thread. Port: both a software port (we ship context between AIs) and a harbor port (where your thread docks at a new tool).