Context that isn't stuck in one harness
Change the harness. Bring the context.
pi saves your sessions to disk, but that file only means something to pi, on that machine. Honcho reads the same sessions and turns them into conclusions any agent can read, so the next tool you open starts where you left off instead of from scratch.
# Install the extension. Conclusions outlive the session. pi install git:github.com/plastic-labs/pi-honcho # Then, inside pi, paste your key once /honcho-setup
$20 in free credits, $80 more when you add a card
What actually travels
Everything is saved. None of it travels.
pi keeps all of it: the message tree, the branches, the compactions. Another agent can technically open that file. What it can't do is tell what mattered, so it re-reads the whole thing at full price to arrive back at what you already settled.
Plus, it's keyed to a working directory on one machine. Open Cursor, or the same repo on the laptop, and the agent starts from nothing. The model groks the code, but knows nothing about you.
The problem is a flat transcript is a record of one conversation in one harness's format, and nothing outside that harness knows what to do with it.
Nothing announces the gap. There's no error. The next agent just re-derives what it could have been handed, and leaves you re-explaining your preferences and style every time.
Reasoning is what makes context portable. Conclusions come out in one standard shape, and every harness reads the same shape.
How it works
One install in pi, then everywhere else
Install it in pi
One command, then /honcho-setup to paste your key. From then on pi loads your profile and the project's conclusions into its system prompt at session start, and sends each exchange back once the agent finishes. The status bar reads Connected, and pi runs normally if it isn't.
Ask it directly
The agent gets three tools it can reach for mid-task: honcho_search for what was decided before, honcho_chat to reason over your history, and honcho_remember to pin a convention so it stops being re-litigated.
Take it everywhere
The same key over MCP gives Claude Code, Cursor, Codex and six more the same conclusions. honcho peer card prints what it's holding about you, from the terminal rather than a dashboard.
# In pi — install, then configure once pi install git:github.com/plastic-labs/pi-honcho /honcho-setup # Scope it to the repo, the branch, or the directory HONCHO_SESSION_STRATEGY=git-branch # In every other client you use claude mcp add honcho --transport http \ --url "https://mcp.honcho.dev" \ --header "Authorization: Bearer hch-your-key"
Honcho reasons over your sessions and keeps a standing set of conclusions about you. Any harness can read the same set; each one decides for itself what to do with it — which is why the same context works in pi, in Claude Code, and in whatever you install next. pi also gets /honcho-status, which prints the workspace, peer, session key and context budget in use. Everything else runs over MCP — documented for Claude Code, Claude Desktop, Codex, Cursor, Windsurf, VS Code, Cline, Zed, and Goose, with a Claude Code plugin at /plugin install honcho@honcho. Setup for each at the MCP guide, and the pi extension at plastic-labs/pi-honcho.
What you get
Up to $100 in credits, $2.00 a million after
Conclusions in one standard shape, not a transcript in pi's. One install in pi, the same key everywhere else.
Ingestion is $2.00 per million tokens — store plus Neuromancer reasoning — so $20 covers 10 million tokens of ingested history and the full $100 covers 50 million. Full rates at honcho.dev and the docs, as of 2026-08-31.
Versus what's already on disk
Keep everything you liked about a flat file
The reason a local transcript feels safe is that you can open it, read it, and delete a line you disagree with. That's a real advantage and most products in this space give it up. Honcho doesn't.
| The session store | Honcho | |
|---|---|---|
| Read back what it knows | grep the JSONL | honcho peer card |
| Throw out a line that's wrong | Edit the file | honcho conclusion delete |
| Harnesses it works in | The one that wrote it | pi, plus nine over MCP |
| Machines it follows you to | Whichever one has the file | All of them |
| Once it gets long | Compacted, and the line that mattered goes | Returns what this turn needs |
| Upkeep | You, forever | Reasons over the sessions you already have |
Honcho sits alongside the setup you already run. It replaces the transcript you re-read by hand, not your editor, your harness, or your model.
Before you commit
The questions you were going to ask anyway
What is this, exactly?
Honcho is a reasoning service. It reads the sessions you're already having, works out what's durably true, and keeps a standing set of conclusions in one format any harness can read. It doesn't store your transcript for you — pi already does that well. What an agent does with those conclusions is up to the agent; Honcho's job is producing them.
What's this actually going to cost me?
Every new account gets $20 in credits, and $80 more once you add a payment method. Ingestion is $2.00 per million tokens, so the first $20 covers 10 million tokens of ingested history and the full $100 covers 50 million — more than a personal setup produces. Reading context back is unlimited and not metered. Reasoning queries are priced per call from $0.001 to $0.50 depending on the depth you ask for, so you're not paying top-tier rates on routine lookups. Full rates at honcho.dev, as of 2026-08-31.
Which tools does this work in?
In pi it's a native extension rather than an MCP server, which is the better deal: no tool definitions sitting in your context, and it can hook the session directly. pi install git:github.com/plastic-labs/pi-honcho registers the three tools and two commands, injects your conclusions at session start, and writes each exchange back when the agent finishes.
Everywhere else it's MCP with the same key: Claude Code, Claude Desktop, Codex, Cursor, Windsurf, VS Code, Cline, Zed, and Goose. The ad-funded free-pi build is the one gap — its CLI takes only --session, so there's no extension loader to hook. It has bash, and Honcho speaks plain REST, if you want it in that loop today.
Can I see and delete what it decided about me?
Yes, and from the terminal rather than a settings screen. honcho peer card prints the stable facts it's holding about you. honcho conclusion list shows what it has concluded, and honcho conclusion delete removes one you disagree with. Piped or redirected, every command emits JSON, so you can diff what it knows about you across a week if you want to.
The same card is readable and writable from the SDKs, where setting it replaces the card wholesale rather than merging — worth knowing before you script against it. Documented under peer cards and the CLI reference.
Can I keep this separate per repo or per branch?
In pi, yes, and per-repo is the default. The thread is keyed to your git remote, so every worktree of the same repo shares one. Set HONCHO_SESSION_STRATEGY to git-branch for a separate thread per branch, or directory to key it to the working directory instead. Set it as an env var or under hosts.pi in ~/.honcho/config.json, and /honcho-status prints which key you're on.
Why not just wait for context windows to get cheap?
A bigger window doesn't carry anything between tools — that's the part that hurts, and it doesn't get better with model releases. It also re-reads your whole history every turn, at full price, to find the two lines that mattered. Honcho charges once per new token ingested rather than on every replay.
Can I run it myself?
Yes, the core is open source at github.com/plastic-labs/honcho. Worth being clear about what that commits you to: PostgreSQL, Redis, and your own model bill. Self-hosting isn't the cheap option for one person, it's the controlled one.
Start building
Switch harnesses without starting over
One install in pi, one key in everything else, and every one of them reads the same conclusions in the same shape. Read them or delete them from the terminal, and take them with you to whatever you open next.
$20 in free credits, $80 more when you add a card