# Poco > Poco makes AI coding agents cheaper by compressing their context - it cuts the token usage and cost of Claude Code, Codex, and Cursor while preserving meaning. --- ## Platform https://thepoco.io/platform POCO / PLATFORM Same meaning. Less tokens. Poco compresses every Claude Code, Codex and Cursor session, then shows you what your agents cost and prevents the LLM from seeing your secrets and PII. Get Poco Open dashboard THE MOMENT YOU INSTALL What you get on day one One command, then one click to authorize. No config files to edit, no workflow to change: Poco finds the agents you already run and hooks itself in. Compression Command output and documents get squeezed before they hit the model. Same meaning, fewer tokens. Your own numbers Every prompt, command and document Poco touched, and the tokens it took out of each. Your dashboard, from the first session. Where you already work Claude Code, Codex and Cursor. Poco finds what you have installed and hooks itself in. Nothing to configure. + Claude Code + Codex + Cursor Fails open. Never blocks your agent. ONCE A FEW OF YOU HAVE IT What your team gets The same hooks that compress the context also see it. That is the whole trick: visibility is free once you are already in the path. AI Discovery Savings & ROI Policy Audit 01 / AI DISCOVERY See every capability your agents load. Every MCP server, sub-agent, skill, slash command and model your team's agents reach for, and what each one costs in tokens before anyone even uses it. 02 / SAVINGS & ROI Know what the AI budget is doing. Tokens and dollars taken off the bill, broken down by model and project, with the trend over time. A number instead of a vibe. 03 / POLICY Set the rules once, for everyone. Decide what gets redacted before it ever reaches a model. The policy applies to every agent in the org, on every machine. 04 / AUDIT Proof of every secret you caught. A running record of the secrets and PII Poco redacted on the way to a model. The evidence for the security review you are going to be asked for. --- ## Benchmarks https://thepoco.io/benchmarks POCO / BENCHMARKS We take the padding. Not the signal. Real commands, real documents, counted with the same tokenizer your model uses. Commands: The numbers COMMANDS 35.5% median saving We drop the command output the conversation never needed. THE NUMBERS → COMMANDS / RECEIPTS ls -la src/ 541 → 12676.7% uv pip list 1,221 → 48060.7% git show HEAD 12,603 → 6,81345.9% Measured with the o200k_base tokenizer, against what the agent would have read without Poco. ← BACK Files: The method FILES Up to 70% Documents are converted into AI-friendly formats. THE METHOD → FILES / METHOD PDF, Word, PowerPoint, Excel and HTML all become Markdown before the model reads them. A PDF is the hungriest of them, and gives back the most: up to 70% fewer tokens, with the content intact. ← BACK MCP servers: The method MCP SERVERS One command prices every MCP server you have installed, and flags the ones you never call. THE METHOD → MCP SERVERS / METHOD A server's tool definitions sit in the always-loaded system prompt. You pay for them every turn, called or not. We price each server, then show you the ones you never call. ← BACK Prompt: The method BETA PROMPT Your prompt, rewritten to say the same thing in fewer tokens. THE METHOD → PROMPT / METHOD Much of a prompt is written for a reader who isn't there. Throat-clearing, hedging, restated context, politeness: the model pays for all of it and needs none of it. We cut the scaffolding and keep the instruction. ← BACK Questions How much does Poco reduce token usage on shell commands? + A median of 35.5% across real commands. How much does Poco save on documents like PDFs? + Can Poco tell me which MCP servers are wasting tokens? + Does Poco rewrite my prompts to save tokens? + --- ## Security https://thepoco.io/security POCO / SECURITY Security by design. Privacy you control. Poco runs inside your coding sessions. This page covers what leaves your machine, what we keep, and the controls you have. .01 HOW IT WORKS Thin client Compute runs on the server Local and remote. The Poco client runs on your machine: it counts tokens, applies your organization's redaction policy, and installs the editor hooks. The compression itself - and command filtering and document conversion - runs on our server, which is why prompts and commands are transmitted. Everything Poco sends travels over TLS, authenticated with your account's API key. Nothing is sent anywhere else. .02 WHAT LEAVES YOUR MACHINE Over TLS Encrypted in transit No surprises. Four things leave your machine, always over an encrypted connection and only ever to our server. What we keep once it arrives is governed by the retention control below. WHAT WHEN WHY Prompt text Every prompt you submit Compressed on the server Commands and their output When Claude runs a shell command Filtered on the server Documents When Claude reads a PDF or Office file Converted on the server Session transcript At the end of each turn Powers your dashboard history Want secrets stripped before they ever leave? An org admin can switch on client-side secret masking, which redacts known secret patterns from prompts on your machine. It is off by default. .03 WHAT WE KEEP Your choice One setting, org admins You decide what is retained. Poco never has to keep your content. One organization setting - Store prompt payloads in Settings - controls it, and your admins decide. Off: prompts, commands, documents, and transcripts are processed and dropped; only metadata and counts (project name, working directory, model, token totals, active AI tools) reach our database. On: content is kept for your dashboard history. Prompt text is masked, and everything stored is deleted after 30 days. .04 INSTALL TRANSPARENCY Open Read it before you run it Nothing hidden. The binary ships unsigned today, and the installer clears macOS's quarantine flag so it can run. We would rather you know that than find it yourself: the install script is plain and readable, and the hooks Poco adds to your editor are readable commands, not obfuscated blobs. Don't want curl | sh? Install the binary alone with POCO_NO_SETUP=1, or authorize non-interactively with POCO_API_KEY instead of the browser. Your key is stored only in ~/.poco/config.toml, readable by you alone. CONTROLS YOU OWN Four environment variables turn features off independently, at any time. CONTROL TURNS OFF POCO_DISABLE_REMOTE_PIPELINE Prompt compression POCO_DISABLE_REMOTE_FILTER Command rewriting & output filtering POCO_DISABLE_SESSION_CAPTURE Session capture - prompt, command, document & transcript upload POCO_DISABLE_FOOTPRINT AI-tool inventory Questions Does Poco compress prompts locally, or on a server? + Both. The Poco client on your machine counts tokens, applies your organization's redaction policy, and installs the editor hooks. Compression, command filtering, and document conversion run on Poco's server, which is why prompts and commands are transmitted - always over TLS, authenticated with your account's API key, and sent nowhere else. What is the 'Store prompt payloads' organization setting? + Can I strip secrets before they leave my machine? + How do I turn off specific Poco features? + Security question, or found something we should know about? Contact us - we would rather hear it from you. --- ## A glossary of AI coding agent terms https://thepoco.io/blog/ai-coding-agent-glossary "Token," "context window," "system prompt," "MCP server" - these terms get thrown around in every AI coding agent's docs, but they're rarely defined in one place, and a couple of them are commonly confused with each other. This is that one place: six terms, plain definitions, and how they connect. ## What is a token? A token is the unit an LLM reads and writes text in - roughly four characters of English, or about three quarters of a word. Every token in a prompt and its response is counted and billed, which is why token count, not character count or word count, is the actual unit of cost. ## What is a context window? A context window is the maximum number of tokens a model can hold in one conversation - the system prompt, tool definitions, prior turns, and the current message all share it. A bigger window does not make any of that free: everything in it is still sent, and still billed, on every turn. Buying a bigger window solves running out of room; it does not solve paying for what's in it. It doesn't solve quality either. Longer context has been shown to measurably degrade a model's answers well before it reaches the window's advertised limit - Chroma's [Context Rot](https://www.trychroma.com/research/context-rot) study found that all 18 frontier models it tested got worse as input length grew, some showing real accuracy loss tens of thousands of tokens short of their stated maximum. ## What is context compression? Context compression is shrinking what gets sent to a model - trimming redundant or low-value text - while keeping the meaning intact, so the model still has what it needs to respond correctly. It's applied to whatever a coding agent sends: prompts, shell command output, documents. [How Poco compresses prompts](/blog/how-poco-compresses-prompts) goes into the mechanics of one specific approach to it. ## What is an MCP server, and why does it cost tokens? An MCP (Model Context Protocol) server is a plugin that gives an AI coding agent extra tools - like querying a database or calling an API. Its tool definitions load into the agent's system prompt the moment it's installed, so you pay for them on every single turn whether you call the tool or not. [Where your context window actually goes](/blog/where-your-context-window-goes) covers why this is usually the single biggest line item people don't expect. ## What is a system prompt? A system prompt is the instructions and context an AI agent sends to the model before your message - its role, available tools, and rules of engagement. It's resent in full on every turn of the conversation, which makes it one of the largest fixed costs in an agentic session, and the reason a bloated tool list or an oversized memory file taxes you long after you stopped thinking about it. ## What is prompt caching, and how is it different from context compression? These two get confused because they both promise lower cost, but they work on opposite ends of the same problem. Prompt caching reduces the cost of resending an identical prefix - like an unchanged system prompt - across turns, but only if that prefix stays byte-for-byte the same. Context compression reduces the size of what's sent in the first place, including the parts that change every turn and could never be cached, like a shell command's output or the current message. Caching pays less for something you already sent unchanged; compression sends less of it to begin with. They're complementary, not substitutes - a session can use both at once. --- ## Where your context window actually goes https://thepoco.io/blog/where-your-context-window-goes Every coding agent you run inside an IDE - Claude Code, Codex, Cursor - spends tokens before you type a single word. That spend is invisible. You see a chat box; underneath, the model is already reading a small book of instructions, tool schemas, and configuration that someone assembled on your behalf. The size of that book is your starting cost, and it has a direct effect on latency, on price, and on how much room is left for the model to actually think about your problem. This post breaks down where those tokens go, segment by segment. ![A horizontal bar showing the context window split into segments: system prompt, tool definitions, an oversized MCP servers block, memory, skills, and a large conversation segment - grouped into a standing tax paid every turn and a metered cost paid on use.](/blog-context-budget.png) ## The one idea: standing tax vs metered A model has a fixed context window - say 200k tokens. It is tempting to picture that as a big bucket you slowly fill over a long session. In practice it is a budget that is **partly pre-committed before the conversation even starts.** Two kinds of cost live in that budget: - **Standing tax** - loaded before the conversation begins and re-sent on every single turn, whether or not you use it. It is multiplied by every request in the session, so it crowds out the window before you have done anything. - **Metered** - paid only when something is actually invoked or produced. It grows as you work, but you control when. Optimizing context consumption is mostly one move: **push things out of the standing column and into the metered one.** Here is what each segment is. ## System prompt The agent's identity, safety policy, tool-use protocol, and output conventions - plus a dynamic environment block (working directory, OS, git status, date, model) spliced in per session. It is a structured document, not a blob: safety and identity go first so later text cannot override them, operational rules sit in the middle, and per-session context is injected at well-defined seams. This is also where instruction priority is set, which is why a skill that says "always use TDD" loses to your project's instructions that say "don't." Standing cost. ## Tool definitions Every callable tool ships a JSON schema - a name, a description, and typed parameters. The model needs all of it in context to call the tool correctly, and a tool you never touch this session still costs its full schema on every request. That pressure is why some agents **defer** tool loading: keep only the tool names in the standing baseline and fetch the full schema on demand, paying a round-trip only when the tool is actually relevant. ## MCP servers This is the line item that surprises people. Connect an external server - Linear, Playwright, a docs bridge - and it advertises its tools, every one of which is injected into your context as standing cost. Forty Linear tools plus twenty-five Playwright tools is thousands of tokens paid on every turn, even if you call one tool once. Two things make MCP cost sneaky: - **It is not knowable from a config file.** The tool definitions only exist once you launch the server and ask it for its tool list. The honest unit is "capacity cost per server," measured by launching and inspecting - not a number you can read off a setting. - **The cost is decoupled from use.** A server you connected three weeks ago "just in case" is taxing every request today. The flip side: MCP is the cost you *chose*, so it is the one you can take back. Disconnect an unused server and its whole schema set leaves the budget. When in doubt, prefer servers with a small, sharp tool surface - eight focused tools beat fifty overlapping ones, both on tokens and on the model's ability to pick the right one. ## Memory and project instructions Your project's instruction file, the memory index, recalled facts. The right structure mirrors skills: a lean index of one-line pointers loaded always, with detail files pulled in only when a specific memory is recalled. Keep the always-on part tight - it is multiplied by every turn like everything else in the standing column. ## Invocable capabilities: skills, slash commands, subagents Skills, slash commands, and subagents are mechanically the same animal, and they get the economics right through **progressive disclosure**: - **Names and descriptions are always loaded** (standing) - the model can only choose a capability it can see. - **The full prompt body is deferred** (metered) until you actually invoke it. So a hundred installed skills cost a hundred one-line descriptions in the baseline - cheap - and you pay the multi-thousand-token body only for the one you use. But progressive disclosure does not mean free: the description line is paid forever, on every turn, for every installed capability. Spend your words there carefully, and keep the body as long as it needs to be. A note on **plugins**: a plugin is not its own line item. It is a container that bundles skills, slash commands, MCP servers, and hooks, which each land in the segments above. Counting "plugins" as a separate slice would double-count the wrapper and its contents. ## Conversation and tool results The baseline gets you to the starting line; tool results fill the rest of the window. A single unfiltered `cat` of a large file, a sprawling `git log`, or a listing of `node_modules` dumps thousands of tokens into the history - where it then re-rides every subsequent request for the rest of the turn. A token you keep out of history is a token you do not re-send next turn, so the savings compound. This is the dynamic-cost twin of the MCP problem: noisy output is a tax you keep paying after the one moment you needed it. ## What to actually do 1. **Prune MCP servers.** Disconnect anything you are not using this week. Usually the single biggest standing-cost win, and invisible until you check. 2. **Measure, do not guess.** You cannot eyeball MCP cost from a config file - launch the server, look at the tool list, count the tokens. 3. **Favor focused tool surfaces.** Fewer, sharper tools beat many overlapping ones. 4. **Write tight descriptions, generous bodies.** For every skill, command, and subagent, the description is the forever-cost; the body is pay-per-use. 5. **Keep memory lean.** Index always-on, detail on recall. 6. **Filter noisy tool output.** Keep the raw dumps out of history so you stop re-paying for them every following turn. The throughline: know which tokens are standing and which are metered, and move things from the first column to the second. A lean baseline is not about doing less - it is about keeping the window clear so the model has room to work on the problem you actually care about. ## Where Poco fits Poco works both columns. On the metered side, it filters the noisy tool output - the big `cat`, the long `git log` - before it lands in your history, so you stop re-paying for it every turn. On the standing side, Poco's AI Discovery measures the footprint you carry into every session: the MCP servers, skills, plugins, and subagents that make up your standing tax, so you can see what each one actually costs and prune what you are not using. --- ## How Poco compresses your prompts (without garbling them) https://thepoco.io/blog/how-poco-compresses-prompts Coding agents are token-hungry. Every turn in Claude Code, Codex, or Cursor resends a pile of context - the conversation so far, files, tool output, logs - and you pay for all of it, every turn. A lot of that text is filler: restated intros, duplicate paragraphs, boilerplate, "just to recap" preambles that carry no new information. Poco compresses that text before it reaches the model. This post explains exactly how, because "AI compression" usually means "we asked another model to summarize it, hope it got the details right." Poco does not work that way, and the difference matters when the text is your code and your instructions. ## Extractive, not abstractive The most important thing to understand first: **Poco never rewrites your words.** It does not paraphrase, summarize, or generate new text. It selects a subset of the sentences you already wrote and drops the rest. The output is always made of your original sentences, in their original order. That choice is deliberate. An abstractive summarizer can hallucinate a fact, soften a constraint, or quietly change "must not" to "should." For a prompt that contains requirements and code, that is unacceptable. Extractive selection cannot invent anything - in the worst case it drops a sentence it should have kept, and the quality gate (below) is there to catch exactly that. ## The pipeline, step by step Compression runs server-side and is deterministic - the same input always produces the same output. There is no extra LLM call in the loop, so it is fast and adds no model cost of its own. Here is what happens to a chunk of text. ### 1. Detect what kind of text it is Before touching anything, Poco classifies the content: natural-language prose, source code, a diff, structured data (JSON / XML / YAML), CLI output, or a log. The detection is heuristic - diff headers, JSON/YAML shapes, log timestamps and levels, language keywords. This step is mostly about knowing what **not** to compress. Code, diffs, and structured data are protected: prose can have its filler trimmed safely, but dropping a line from a JSON blob or a patch would corrupt it. Short text is skipped too - there is nothing to gain from compressing a one-line prompt. ### 2. Split into sentences and drop exact duplicates Poco splits the text into sentences and removes ones that are byte-for-byte identical to a sentence it has already seen, using a fast hash (FNV-1a). Long agent transcripts repeat themselves a lot - the same file header, the same status line, the same error - and de-duplicating is a free win that loses nothing, because an identical sentence carries no new information. ### 3. Score each sentence by how much it carries Every remaining sentence gets a score based on its information density, with a penalty for boilerplate - lines containing markers like "all rights reserved", "click here", "subscribe", "privacy policy". Dense, content-bearing sentences score high; padding and boilerplate score low. ### 4. Keep the highest-value sentences, in order Poco keeps the top-scoring sentences up to a budget, then **re-sorts the kept sentences back into their original order** so the result still reads top to bottom the way you wrote it. How aggressive the trim is depends on the content type from step 1: natural-language prose is trimmed the most, while code and structured data are barely touched, if at all. ### 5. Check the result, and fail safe This is the part that makes the rest trustworthy. Poco scores the compressed text against your original on two axes: - **ROUGE** (unigram overlap and longest-common-subsequence recall) - how much of the original wording survived. - **Information density** - the fraction of the original's unique content terms that are still present. Those produce a letter grade, A through F. If the compressed version does not clear a minimum grade, **Poco throws it away and sends your original text unchanged.** Compression is only applied when it both saves tokens and passes the fidelity bar. The default is to never ship a low-fidelity result. ## What Poco deliberately does not do - It does not rewrite or paraphrase your text. - It does not compress code, diffs, or JSON/YAML/XML structure. - It does not touch short prompts. - It does not ship a compression that fails the quality gate - your original goes through instead. ## Honest about the limits Compression is lossy by design: Poco drops sentences it judges to be filler, and on text that is already dense it will (correctly) do very little. The savings depend entirely on how much redundancy your prompts actually contain, which varies a lot between workflows. We are not going to quote you a headline "X% saved" number we cannot stand behind yet - rigorous, reproducible benchmarks are in progress, and we would rather show you real numbers than marketing ones. In the meantime, the most honest benchmark is your own: Poco tracks the tokens it saves on your actual prompts. See the current state on the [benchmarks page](/benchmarks), and watch your own savings by installing it. ## Try it Poco installs in one line and wires itself into Claude Code, Codex, and Cursor: ```sh curl -sSL https://get.thepoco.io | sh ``` That is the whole setup. [Full install guide](/install).