Coders Talk Plugin MCP Server

KeepPlain for Claude Code, Codex, Cursor and Pi

Send the Claude Code, Codex, Cursor or Pi session you are in to KeepPlain as a draft Build: the prompts, interventions and fails that mattered, with the raw log one layer down. The plugin never publishes. The draft is private: only you see it, or your team when the session ran in one of the team's repositories. You review every moment on the site and publish it there if you want to.

The other way round, the plugin gives your agent the KeepPlain library: before a non-trivial task, or after a few failed attempts, it can look up sessions where other developers did something similar, and what went wrong for them (see The library in your agent). And /keepplain:use puts a published Build's playbook, what that session learned the hard way, into your repository as a skill or a rule (see Playbooks).

Install

Coming from Coders Talk

KeepPlain was called Coders Talk until October 2026, and the plugin does not take the old one over: take it off first, or its hooks run next to the new ones.

1. coders-talk disable takes it out of Claude Code, Codex, Cursor and Pi.
2. Delete ~/.coders-talk and the # Coders Talk CLI line in your shell profile (on Windows, %USERPROFILE%\.coders-talk\bin in your PATH).
3. If you added Coders Talk from Claude's plugin directory, remove it in Customize → Plugins; the Coders Talk desktop app, in Settings → Apps.
4. The new plugin leaves the old blocks alone: delete `` blocks in CLAUDE.md or AGENTS.md and # >>> coders-talk blocks in git hooks.

Then install as below and sign in again with /keepplain:login (or keepplain login).

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=<slug>, --keep=<numbers>, --continues=<link>). 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 <id> and keepplain send <id> (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
   

2. 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 <event>), skills/keepplain-<name>/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/<folder>/agent-transcripts/<id>/<id>.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 each workspace is in (in ~/.keepplain/cursor/: times and counts, never the text), so keepplain preview finds the conversation of the folder it runs in without being told. What each turn changed comes from the agent's own edit calls and the git snapshots. Cursor does not always call sessionEnd (a closed window, a crash): the next sessionStart sends what was left.

Pi

keepplain enable installs it with pi install. From this repository instead, without the file:

pi install git:github.com/keepplain/keepplain-plugin

That runs the scripts with Node.js, which Pi needs itself (22.19 or newer). Type /reload or start Pi again, then /keepplain:login and /keepplain:build. The plugin is one extension (pi/extensions/keepplain.js, named by the pi key of package.json). Its commands run in Pi's own process, so nothing of them lands in the session, and the question "Send this session?" is Pi's own dialog. Its events (session_start, agent_start, agent_settled and session_shutdown) run the same hooks the other agents have: auto mode, the git snapshots and the suggestion to share. The session is the file Pi keeps in ~/.pi/agent/sessions (or where PI_CODING_AGENT_DIR, PI_CODING_AGENT_SESSION_DIR or the sessionDir setting put it); the extension tells keepplain which one, as Pi does for the commands it runs itself (PI_SESSION_ID, PI_SESSION_FILE). Pi has no MCP, so the extension registers the library's three tools itself; they ask the site through keepplain mcp-call with your sign-in. A fork (/fork, /clone) is a new file that names its parent: it is sent as its own draft, linked to the original. Pi reads a repository's own .agents/skills (where use puts a playbook) only in a project you trusted.

One repository

One repository serves all four agents: Claude Code reads .claude-plugin/ and skills/, Codex reads .codex-plugin/, .agents/plugins/marketplace.json, codex/skills/ and codex/hooks.json (its manifest points there, so Codex never picks up hooks/hooks.json; the same scripts run with --agent=codex), Pi loads the extension the pi key of package.json names, and cursor/skills/ holds the skills enable copies into ~/.cursor. Codex does not expand ${CLAUDE_PLUGIN_ROOT} or ${CLAUDE_SESSION_ID} in skills, so its skills give the script path relative to the skill file and pass --agent=codex.

Claude Code on the web

A session on claude.ai/code keeps its whole transcript in its cloud machine (~/.claude/projects/… there). Teleporting it to your computer brings only the part after its last compaction, so /keepplain:build there sends a long session without its beginning. The cloud machine installs no plugins, though, and reaches KeepPlain only when its environment allows it. So a cloud session sends itself another way, with nothing to set up in the environment:

1. Connect the KeepPlain connector in claude.ai (connector settings). The same connector gives the agent the library. A connection made before connectors could send sessions can only read: disconnect and connect it again (the upload tools say so).
2. Add the KeepPlain skill: download keepplain-skill.zip from the latest release and upload it in claude.ai's skills settings. Cloud sessions load the skills you enable on claude.ai by themselves.
3. In a cloud session, ask: "send this session to KeepPlain" (or, with this plugin on your claude.ai account, /keepplain:build: in a cloud machine with no token of its own it takes the same route by itself). The skill runs this plugin's script in the cloud machine: it finds the session (the newest transcript there), shows what goes and what the privacy check found, and asks. Then the connector's start_session_upload hands out a one-time upload link (15 minutes) in the site's storage (Cloudflare R2, which the cloud's default network list allows), keepplain send --connector --upload=<link> puts the session there, and finish_session_upload makes the draft and returns its link.

The skill is built by node scripts/skill.mjs (dist/keepplain-skill.zip: its SKILL.md is web-skill/SKILL.md), and each release carries it.

The proxy of a cloud machine looks inside TLS with its own CA. The plugin trusts it from SSL_CERT_FILE, REQUESTS_CA_BUNDLE, CURL_CA_BUNDLE, the system store (Node 22.15 and newer) or ~/.ccr/ca-bundle.crt, where Claude Code on the web keeps it, on top of Node's own CAs and NODE_EXTRA_CA_CERTS. Where KeepPlain itself is refused by a proxy, the plugin says so and, in Claude Code on the web, which environment setting lets it through.

Use

The commands are the same in every agent, typed its way: /keepplain:build in Claude Code and Pi, $keepplain:build in Codex, /keepplain-build in Cursor. The tables below use the first.

Sending the same session again updates its draft until you publish it.

Two rules:

• Commands that send your session (build and auto, and login and logout with them) run only when you type them. The agent never invokes them on its own (in Cursor their skills are marked so; in Pi they are extension commands, which only you can type).
• Putting a playbook into your repository (use) runs only when you type it too. The library may tell the agent that a session has a playbook; the agent can only pass that on to you.
• Searching the library is something the agent does by itself when a task calls for it (the lookup skill and the keepplain MCP server). It sends a short description of the task and the stack, never the session. Switch it off in /mcp (Claude Code), in ~/.codex/config.toml (Codex) or in Settings → MCP (Cursor); see The library in your agent.

A forked session (/branch or --fork-session in Claude Code, a fork in Codex, /fork or /clone in Pi) is sent as its own draft, and the plugin tells the site which session it came from and where it left it. The fork's Build then says it is a fork and links to the Build of the original session, and the original's Build links to its forks. Whichever of the two is sent first, the link appears once both are on the site. Claude Code writes the lines the fork inherited with the original's session id and Codex names it in the rollout's session_meta and Pi in the header of the new file, so no hook is needed for it. Cursor's transcripts do not say whether a conversation was forked.

If the privacy check found something the preview lists it by number; it goes as [REDACTED] unless you name its number, and the preview runs again with --keep=<numbers> (see What leaves your machine).

If KeepPlain cannot be reached or answers with a server error, the send step opens keepplain.com/new in the browser and the file manager with the prepared .jsonl.gz selected, and prints the link and the path: drop the file on the page. It is the same checked file the preview described. It is kept for 30 minutes, so sending again once the site is back works too; after that the next run of keepplain (or the next session start) deletes it. KEEPPLAIN_NO_BROWSER=1 keeps the browser and the file manager closed; the link and the path are printed anyway. A rejected token or request never ends up there: sign in again instead.

Auto mode

Off until you turn it on, per computer, per site and per agent: /keepplain:auto on in Claude Code never sends Codex, Cursor or Pi sessions, and the other way round. With it on, each session is sent the way /keepplain:build would send it, without asking: to your team's space when the repository is one of your team's, else to your private Builds. With /keepplain:auto team, only sessions in repositories of teams that ask for it (a team setting) are sent, and nothing else leaves the machine. A team can ask; it can never switch this on for you.

One session can choose for itself. /keepplain:auto session on sends the current session the way on would, even while auto mode is off for the computer; other sessions are not touched. /keepplain:auto session off keeps the current session on the computer whatever the mode, the git hooks' push included (what it already sent stays a draft). The choice is kept in auto-sessions.json with the session, so a resumed session keeps it, and /keepplain:auto off does not forget it. KEEPPLAIN_AUTO=0 still stops everything.

These hooks do the sending, each in a background process so the agent never waits for an upload:

• Stop, after an answer of the agent: when the session grew and the last send is five minutes old, it is sent as still going. The draft stays up to date, and a crash loses at most those minutes. A session shorter than five minutes is only sent at its end.
• PostToolUse (Claude Code), after each tool call: the same check, so a turn the agent works on for an hour is sent while it runs, not only once it answers. Claude Code runs it without waiting for it (async), and it loads nothing but auto mode.
• SessionEnd: the session is sent once more, as ended. Codex also ends a session after 30 idle minutes, which is what ends one in its desktop app.
• SessionStart: sessions that never said they ended (a crash, a closed terminal) and grew since their last send are sent at the next start, up to three at a time. One quiet for half an hour goes as ended; a fresher one as still going. Only sessions auto mode saw while it was on, or turned on for themselves, are considered, never older history: that is the one-time import's (Past sessions).

The site asks the model for moments when a session is over: when the plugin says it ended, or after half an hour without anything new. A session that goes on after that is asked about again at its next end, from the whole session, as long as you have not changed the timeline yourself. Sending a session that is still going costs nothing and does not count against the daily limit.

A conversation in the Claude app can be several sessions: the app starts a new one, with the lines up to there copied in, whenever you edit a message you sent and when a conversation is continued. The plugin sends such a chain as one session, under the newest one's id, and names the sessions before it (chain), so the site keeps updating the one draft. A late send of a session the conversation already went on from is left alone (skipped: the conversation went on in a later session).

Nothing is published by it. A session you already published is left alone. Every send gets a line in ~/.keepplain/auto.log: sent or synced (with the draft link), skipped and why, or failed. The log keeps its last 500 lines, none older than 30 days. ~/.keepplain/auto-sessions.json remembers which sessions auto mode saw and how much of each went, never their content; /keepplain:auto off forgets it. KEEPPLAIN_AUTO=0 in the environment turns auto mode off for that shell.

In Cursor the hooks are the ones enable wrote into ~/.cursor/hooks.json (sessionStart, stop and sessionEnd, and beforeSubmitPrompt, which only notes the turn); nothing has to be trusted. The IDE does not call sessionEnd every time, so the site also asks for moments after half an hour without anything new, and the next sessionStart sends what was left. In Pi the extension runs the hooks on session_start, agent_settled (after an answer) and session_shutdown; Pi waits for the last one, so the upload starts in the background before it exits.

In Codex the hooks are codex/hooks.json. Codex runs a plugin's hooks only once you trust them: type /hooks and trust the three KeepPlain hooks ($keepplain:auto on reminds you). On Windows Codex runs them through PowerShell and puts the plugin folder into ${PLUGIN_ROOT} itself. When the Codex CLI exits it also ends what its hooks started, so the session-end hook waits up to three seconds for the upload; what does not make it goes at the next start, and the site asks for moments after half an hour without anything new anyway.

Past sessions

Your memory starts empty: search_my_work and "why did this change" find only what the site has. Your agents still keep the sessions they ran before the plugin did (Claude Code about 30 days in ~/.claude/projects, Codex in ~/.codex/sessions, Cursor in ~/.cursor/projects, Pi in its sessions folder), so keepplain enable, the desktop app's welcome and keepplain import-past offer to import them. The import runs once per account: the site takes past sessions for 14 days from the first one, and after that the plugin no longer offers it.

• It finds the sessions of the last 30 days (--days=N, up to 90) with a prompt in them, quiet for half an hour, neither sent from this computer nor known to auto mode (sent.json, auto-sessions.json; a session you turned off with auto session off never goes), says how many of which projects, and asks [Y/n]. Without a terminal it asks nothing and sends nothing unless it is told yes: keepplain import-past start, import-past --yes, enable --yes --import-past (the app's tick). import-past --json says what it found, by agent and project, and whether the site still takes them.
• A yes sends them as auto mode would (auto-send <id> --past): the same slimming, the same redaction on this computer and privacy.json's words. They always go to your private drafts, whatever the repository; a team gets only those you share with it (below). The site takes them as trigger=backfill: dated by when each session ran, not when it was sent, labelled through the Batch API, and counted against an allowance of their own (100 a day, also after you share some with a team), never auto mode's nor the team's. An empty one is dropped without a notification.
• In the background, oldest first, one every 15 seconds (the site takes five sends a minute). When the day's allowance is used up, it stops until midnight UTC and goes on at the next agent session start, at keepplain login or at keepplain import-past. A busy site is waited for a minute; one out of reach, half an hour; a session the site keeps failing on is tried three times, then left out. A sign-in the site no longer accepts puts the import back to waiting for keepplain login, with nothing lost. A Claude app conversation of several sessions goes as one draft, as in auto mode. Auto mode leaves these sessions alone until you go on with one of them.
• A session's commits are those up to when it ended, on the branch it ran on when that is still here, not everything up to today's HEAD.
• Cursor's transcripts do not say which folder they ran in. The folder is the one of Cursor's workspaces (its workspaceStorage) or of another agent's session whose name gives Cursor's folder name; a conversation whose folder stays unknown is left out, and the count says so.
• Not signed in yet (enable before login), it waits and starts at the sign-in.
• Sessions that ran in repositories of one of your teams (its GitHub owners, as the site routes them) are offered to that team, one question per team, in a terminal right after the import's question (or at keepplain login when you agreed before signing in): "14 of these sessions ran in Acme's repositories. Share them with Acme too?" Yes by default only when your auto mode already sends this computer's sessions there (on, or team for a team that asks for it) and the team waits for no new consent from you; otherwise no. The desktop app shows the list with a tick for each. The ones you share move to the team right after they are imported (POST /api/v1/teams/<team>/sessions); one already imported, at once. Nothing moves into a team whose changed terms you have not agreed to. import-past teams --json lists them; import-past share --team=<slug> --stdin takes the ids that go ([] keeps them all private). Join a team later and the site offers the same in the bell and on the team's consent page, once for each lot.

keepplain import-past status says how far it got and why it waits; keepplain import-past stop stops it, and what was imported stays in your drafts. ~/.keepplain/past-import.json holds the import's sessions (their ids, files, folders, project names and repository addresses, never what was said in them) and its counts; the lists go 30 days after the import ended. auto.log gets a line per session, as for auto mode. enable remembers a no and does not ask again; keepplain import-past asks again when you want it.

Private and team drafts

A draft is private: it is in your My builds, not in the feed, search engines or your profile. If you are in a team on KeepPlain and the session ran in a repository of one of the GitHub organisations the team named, the draft goes to the team's space instead: the team sees it, nobody else. The preview says where the draft goes before anything is sent; --private and --team <slug> override it. Publishing to the community is always a separate step on the site, and for a team's draft only if the team allows it.

The library in your agent

The plugin brings an MCP server, keepplain (https://keepplain.com/mcp), to Claude Code, Codex and Cursor, and the same tools as the extension's own to Pi, which has no MCP. There are three, all read-only: search_coding_agent_sessions finds published sessions of a similar task, get_coding_agent_session reads one of them, find_coding_agent_failures finds where agents failed on a similar problem and what the human did. The lookup skill tells the agent when to use them (before a non-trivial task on a known stack, after two or three failed attempts, when you ask how others did something), what may go into a query and what may not, and to treat the answers as other people's experience: it never runs a command from them without asking you. When a session helped, it says so with the link.

• Signing in. In Claude Code the server uses the sign-in of /keepplain:login: .mcp.json asks scripts/keepplain.mjs mcp-headers for the token at each connection (headersHelper), so the token is in no config file and never passes through the chat. Not signed in, the server asks you to sign in through the browser in /mcp. Codex runs a plugin's header helper from the session's folder with an empty environment, where the plugin cannot find its own script, so in Codex the server signs in on its own: run codex mcp login keepplain once. Cursor signs in on its own too, to the server enable put in ~/.cursor/mcp.json: Settings → MCP → keepplain → Connect. Pi's tools use the sign-in of /keepplain:login. Searching the library needs no account; signed in, the server also searches your team's sessions and lifts the guest limits: see keepplain.com/for-agents.

• What a search sends. The query (a few words about the task, or the symptom of a failure), the stack, and the agent's name. The agent is told never to put code, paths, repository, company or client names, hostnames, URLs or secrets in it. The site keeps the query text, the filters and how many results it found for 180 days, not tied to you or your IP address. The session itself never goes with it.

• Switching it off. Claude Code: /mcp, choose keepplain, disable. Codex: in ~/.codex/config.toml

  [plugins."keepplain@keepplain".mcp_servers.keepplain]
  enabled = false
  

  Cursor: Settings → MCP, or delete keepplain from ~/.cursor/mcp.json. Pi: pi remove the package, or keepplain disable.

• Another site. The plugin's server always points at https://keepplain.com/mcp: the Claude desktop app compares the address it shows with the session's and does not expand variables, so a ${…} address breaks signing in there. For another site add your own server and switch the plugin's off: in Claude Code claude mcp add --transport http keepplain-dev http://…/mcp, in Codex [mcp_servers.keepplain-dev] with url = "http://…/mcp" in config.toml, in Cursor another entry in mcp.json. Pi's tools ask the site that KEEPPLAIN_URL names. Sending sessions still follows KEEPPLAIN_URL and the plugin option url.

• Which Builds your session used. When you send a session, the plugin counts the agent's calls to these tools in it and collects the Builds their answers linked to (/b/<slug>?ref=agent), up to 20, and the Builds whose playbooks the agent worked with: a kp-<slug> skill it ran (ct-<slug> before the rename; the Skill tool, or /kp-… typed in Claude Code; a <skill> block, or the agent reading the skill's SKILL.md, in Codex or Pi; /kp-… typed in Cursor), by the Build's link at the end of the skill's text. Cursor's transcript keeps no tool results, so from a Cursor session only the number of calls is known, not the Builds they returned. A playbook written as a rule into AGENTS.md or CLAUDE.md is in every session whether it helped or not, so it is not counted. The preview shows them. The site links your draft to those Builds: "Used from the library" and "Built with the playbook from @author" on yours, "Helped N published sessions" and "N built with its playbook" on theirs, once yours is published. Only the count and the slugs are sent, not the queries: in the session itself each library call goes as the tool's name with [library call — not kept] in place of the query and of the answer. The count and the slugs are taken from the session file on your computer before that.

• A suggestion to share. Once per session, after an answer, when the agent got Builds from the library and the session changed code, the Stop hook shows you one line: "Your agent used 2 Builds from KeepPlain in this session. Share yours: /keepplain:build". It sends nothing, and it never shows with auto mode on. To read the session for it, the hook goes on from where it stopped the last time and keeps that place, the count and the slugs in ~/.keepplain/nudges/. Turn it off with KEEPPLAIN_NUDGE=0, or node <plugin folder>/scripts/keepplain.mjs nudge off. In Codex the hook runs only once you trust the plugin's hooks in /hooks.

Playbooks

A published Build can come with a playbook: what its session taught, written for an agent from the Build's page (when to use it, the approach, the pitfalls, the checks, and a better first prompt). /keepplain:use <link or slug> ($keepplain:use in Codex, /keepplain-use in Cursor, keepplain use in a terminal) shows it in full, says where it would go and what changed since the version already here, and writes it only after you say yes.

• The paths are at the root of the repository you are in, or in the folder itself outside a repository. A skill is a folder of its own: delete the folder and it is gone. The agent opens it by itself when a task matches its description; its front matter has a name and a description and nothing else, so no tool permissions.
• A rule is the block between and; the rest of the file stays as it was, line endings included. When CLAUDE.md imports @AGENTS.md, the block goes into AGENTS.md once and both agents read it. With both files and no import, it goes into the file of the agent you chose, and the output says the other agent will not see it.
• .keepplain/uses.json in the repository notes what was written: the Build, the version, the format and the agent. Nothing updates by itself: use again shows what changed and asks again.
• In a terminal it asks [y/N] before writing, and asks for which agent when both are on this computer. For scripts, --agent=claude|codex|cursor|pi and --write answer both.
• It asks the site for one public file, /b/<slug>/use/<format>.md, with via=cli and the agent; the request that goes with writing adds write=1, which the site counts as a use (once a day). Nothing about your repository goes with it, and no token: only when the file is not public (a Build of your team that is not published) does it ask again with your sign-in, and only this site ever gets it. A team's own Build is not counted.
• Your team's rules: use --team=<team> --stack=<stack>, as the team's page shows it. The rules the team merged for that stack, in one block in CLAUDE.md or AGENTS.md (``), written the same way as a rule. A rule changes only when the team merges a proposal on the site, so every member gets the same block. For members only, so it needs the sign-in. When the block here is older, use --team names the proposals merged since.
• Kept up with: at the start of a session in a repository with a team's block, the SessionStart hook says in one line when the team merged a proposal since the block was written, from what the last check found. It never goes to the network itself: when the last check is over six hours old it starts one in the background (GET /t/<team>/rules/<stack>.md with If-None-Match and your sign-in; the site answers 304 until a merge), and notes the result in ~/.keepplain/team-rules.json. It never rewrites the block: use --team does, when you run it.
• Once written, it prints the Build's link with ?ref=use: open it after your agent has worked with the playbook and say whether it worked for you.

Continue in another agent

When the usage limit of the agent you are in is nearly used up, the plugin offers to go on in another one installed on this computer, and gives it a brief of the session so you do not start from nothing. Nothing leaves the computer, and no sign-in is needed.

Documentation truncated — see the full README on GitHub.