Coders Talk

KeepPlain

Your coding agent forgets everything when a session ends. KeepPlain keeps that history, so you stop explaining the same thing twice.

Works with Claude Code, Codex, Cursor, Pi and Antigravity. Free for personal use, teams pay per seat.

curl -fsSL https://keepplain.com/install.sh | sh    # macOS and Linux

irm https://keepplain.com/install.ps1 | iex # Windows, in PowerShell keepplain login keepplain enable

One file, no Node.js, no sudo. enable says what it found and asks before it changes anything. More ways to install

What it does

Find what you already solved. Your agent searches the sessions you sent to KeepPlain and opens the turn with the answer. /keepplain:resume picks a task up in another agent.

Stop correcting it twice. Once a day a model reads your sessions and suggests the mistakes that came back in two conversations or more. Add one in a click and your agents get it at the start of a session or with the prompt it matters for. Rules

Keep going at the limit. Past 90% of Claude's 5-hour or weekly limit, you get a button to continue in Codex or Pi. The brief is built on your computer without a model, and it needs no sign-in. Handoff

See which session wrote a line. keepplain blame is git blame with the agent session behind each line. Blame

● Claude Code · Harden the webhook   4 │ const TOLERANCE_SEC = 300;

○ Pi · Seat count sync 19 │ await syncSeats(event.data, { lock: 'team' }); ● Codex · maya, private 22 │ await markPaid(event.data.id, { notify: true }); no session found 25 │ return new Response('ok');

Learn from other people's sessions. Before a hard task, or when it's stuck, your agent can check the public library for how others got past the same problem. Library

What leaves your computer. Sessions are sent only when you run /keepplain:build and confirm, or after you turn on auto mode. They are stored on keepplain.com as private drafts, and nothing is public until you publish it on the site. Secrets are replaced on your computer before anything is sent. That check works by patterns and can miss things, so read the preview. This plugin is MIT, the site is not open source. The full list

Install

From a terminal

curl -fsSL https://keepplain.com/install.sh | sh        # macOS and Linux

irm https://keepplain.com/install.ps1 | iex # Windows, in PowerShell keepplain login

This installs keepplain, one file with no Node.js needed, into ~/.keepplain/bin and adds that folder to your PATH (the rc file of your shell; on Windows the user PATH). The installer takes the file for your platform from this repository's releases and checks it against the release's SHA256SUMS. No sudo or administrator rights. KEEPPLAIN_VERSION=0.16.0 installs that version, KEEPPLAIN_NO_MODIFY_PATH=1 leaves PATH alone.

keepplain login waits in the terminal until you press Connect in the browser; over SSH it prints the link and the code to open elsewhere. keepplain update replaces the file with the latest release after checking its SHA256. A command you type mentions a newer release in one line, at most once a day; it never waits for the network to do so, and hooks never check. KEEPPLAIN_NO_UPDATE_CHECK=1 turns that off.

Then keepplain enable connects Claude Code, Codex, Cursor and Pi to it. It says what it found and what it will do, asks, and then installs the plugin through each agent's own plugin system: it lays the plugin out in ~/.keepplain/plugin and adds that folder as the local marketplace keepplain-local (claude plugin marketplace add, claude plugin install keepplain@keepplain-local; codex plugin marketplace add, codex plugin add), and installs Pi's package from it with pi install. Cursor has no command that installs a plugin, so it gets what the plugin is made of as files of its own folder, ~/.cursor, next to whatever is there: the hooks in hooks.json, the commands as skills in skills/keepplain-* and the library in mcp.json. Only what is ours is ever changed in them, and a file it cannot read (comments, a syntax error) is left as it is and the lines to add are printed. It is the same plugin as the one below, but its hooks and skills call keepplain by its absolute path, so no Node.js is needed and desktop apps find it without your shell's PATH. On the way it:

• replaces the plugin from the GitHub marketplace (keepplain@keepplain), or Pi's git package (pi install git:github.com/keepplain/keepplain-plugin), whose hooks would otherwise run twice;
• leaves the plugin from Claude's plugin directory (keepplain@synced) as it is and installs no copy of its own into Claude Code next to it; another copy there goes. The directory's copy is removed on claude.ai, not by disable;
• finds a KeepPlain MCP server you added by hand (claude mcp add, mcp_servers in Codex's config.toml, an entry in ~/.cursor/mcp.json) and removes it, or keeps it and installs the plugin without its own server for that agent;
• asks once about auto mode for every agent it found (off unless you say otherwise). Codex runs the hooks only after you trust them in /hooks; enable does not do that for you. Cursor and Pi need nothing of the kind;
• in a git repository, asks whether to put the KeepPlain git hooks into it (no, unless they are there already; see Git hooks);
• asks once whether to import your sessions of the last 30 days to your private drafts (yes, unless you say no; see Past sessions).

keepplain enable --yes goes ahead without asking, with --agent=claude-code,codex,cursor,pi, --auto=off|on|team|push, --mcp=remove|keep, --git-hooks, --no-git-hooks or --no-trailers, and --import-past (with --import-days=N) for the answers; without --import-past it imports nothing. keepplain status shows the file, the sign-in, each agent's KeepPlain plugins and auto mode, and the git hooks of the repository you are in. keepplain disable uninstalls the plugin and its marketplace from Claude Code and Codex, removes Pi's package, takes the hooks, skills and library entry it wrote out of ~/.cursor, and takes the git hooks out of every repository enable put them in; the sign-in, your settings and the file stay. keepplain update lays the plugin out again in the new version and updates it in the agents, so the plugin's version is always the file's.

To send a session without going back into it, run keepplain sessions in the folder it ran in (or keepplain sessions --all anywhere, for every project's sessions of the last 30 days): it lists that folder's Claude Code, Codex, Cursor and Pi sessions (also those run at the top of its repository), newest first, with how many prompts each has, the start of the first one and whether it was sent already. keepplain build 2 then shows the same summary and privacy check as /keepplain:build, asks [y/N] and sends; keepplain build alone takes the newest session, and a session id works too. It takes the same options (--private, --team= , --keep= , --continues= ). It runs only in a terminal: neither an agent nor a script can answer its question, and there is no --yes. From a script, keepplain preview and keepplain send (with --agent=codex, --agent=cursor or --agent=pi for the others) do the two steps.

A KeepPlain connector your organisation added in claude.ai is not visible on your computer, so enable cannot find it. If the agent then lists the library's tools twice, turn one of the two servers off in /mcp.

Programs read the commands with --json: status, sessions, preview, send, discard, login, whoami, logout, enable, disable, auto, rules, nudge, privacy and import-past print one JSON object a line, the long ones an {"event": …} per step, and a failure as {"error": "…"} on stdout. The preview's findings come by number and kind only, never a value. login --json waits for Connect until the code expires.

The desktop app

KeepPlain app is a window over the same commands for macOS and Windows: a three-step welcome (the agents found, sign-in, enable, with a tick, on by default, for the import of past sessions), the agents with a switch each, the last session sent, every project's recent sessions (sessions --all) with a confirmation screen before each send, and the settings. It carries a released keepplain file and installs it in ~/.keepplain/bin when that one is missing or older.

From Claude's plugin directory

KeepPlain is listed in Claude's plugin directory. On claude.ai or in the Claude desktop app, open Customize → Plugins, find KeepPlain and press Add, then start a new session; the desktop app runs the plugin's scripts with Node.js 20 or newer. Claude Code in a terminal gets it too when it is signed in with the same account, as keepplain@synced. Then /keepplain:login as below. Keep one copy: keepplain enable leaves this one and puts none of its own into Claude Code, but the marketplace below next to it runs the hooks twice.

From the agent

1. In Claude Code:

   /plugin marketplace add keepplain/keepplain-plugin

/plugin install keepplain@keepplain

1. Connect it to your account: /keepplain:login. It opens KeepPlain in the browser; check that the page shows the same code as Claude Code and press Connect. The plugin receives its token directly from the site and keeps it in ~/.keepplain/credentials.json, readable by you only. There is no token to copy, and it never passes through the chat. The sign-in request names only the program asking (Claude Code, Codex, Cursor, Pi or KeepPlain CLI) and its version, not your computer; the site lists the token under that name in Settings → Agent plugins.

Needs Node.js 20 or newer, nothing else.

Codex

codex plugin marketplace add keepplain/keepplain-plugin

codex plugin add keepplain@keepplain

Start a new session, then $keepplain:login and $keepplain:build (the same commands as below, with $ instead of /). For the library, also run codex mcp login keepplain once in a terminal. Codex asks to run the plugin's command outside its sandbox: it needs the network to reach KeepPlain and your home folder for the sign-in. The session is found through CODEX_THREAD_ID in ~/.codex/sessions (or CODEX_HOME), and HEAD at its start comes from the rollout's session_meta, so Codex needs no hook for it. Codex runs the plugin's hooks only for auto mode (see Auto mode), and only once you trust them in /hooks.

Cursor

keepplain enable (above) is the way in: Cursor has nothing that installs a plugin from a script, so it writes the plugin into ~/.cursor, where the IDE and the agent CLI read it at every start. hooks.json gets four hooks (sessionStart, beforeSubmitPrompt, stop and sessionEnd, each running keepplain hook cursor ), skills/keepplain- /SKILL.md the commands, and mcp.json the library. Restart Cursor (or run "Developer: Reload Window"), press Connect for keepplain in Settings → MCP, then type /keepplain-login and /keepplain-build: the commands below with a hyphen for the colon, since a skill's name in Cursor cannot hold one.

Cursor's transcript of a conversation (~/.cursor/projects/ /agent-transcripts/ / .jsonl) has the prompts, the answers and the tool calls, but no tool results, no token counts and no time but the minute. The hooks add what it lacks: beforeSubmitPrompt and stop note the time of each turn, the model, the tokens of each answer and which conversation eac