Paritok Review (2026): Pricing, Features & Honest Verdict

Paritok is a compression gateway that sits between your coding agent and the model API, shrinking tool schemas, file reads and stale history before they get billed. It cuts input tokens 25% on turn one and past 60% by turn twenty. Best for: teams running Claude Code or Cursor all day. Price: free self-hosted, $0.30 per 1M tokens managed. Rating: 8/10.

What is Paritok?

Paritok is a proxy. You point your coding agent at it instead of at Anthropic or OpenAI, it rewrites the request on the way out, and the response comes back untouched. The whole integration is one environment variable: export ANTHROPIC_BASE_URL=http://127.0.0.1:8080. That is the entire setup, and we checked, because a drop-in claim that needs a config file and a rewrite of your agent harness is not a drop-in claim.

We found Paritok on Product Hunt at version 1.3.0, licensed Apache-2.0, with the model weights on Hugging Face, Ollama and PyPI. The GitHub repo was created on 15 July 2026 and sits at roughly 970 stars. So this is a young project. The pitch is narrow and the numbers are specific, which is rarer than it should be in this category.

What are Paritok’s key features?

Tool schema filtering that stays cache-stable

Agents ship every tool definition in full JSON on every single request. Paritok’s own example counts 46 schemas at 29K tokens per turn, and it keeps the relevant ones while stubbing the rest, dropping that block to about 8K. The part that matters more than the ratio: the filtered block is frozen for the conversation. If it changed per turn it would break prompt caching upstream and you would pay more, not less. Someone thought about that.

Compressed file reads and tool output

File reads and command output get compressed to about 26% of their original size by a 4B model trained on 45,000 real agent trajectories. The claim is that identifiers, paths and error strings survive while prose and boilerplate do not. This is the lever that compounds, because every file your agent reads stays in history and gets re-sent on every subsequent turn.

read_original, so nothing is actually gone

This is the feature that makes the rest defensible. Every compressed segment is tagged with a reference, and the agent can call read_original("a41") to get the exact bytes back. Locally, without burning an upstream turn. There is a companion gateway_search_tools(q) for the stubbed tools. Compression is lossy on the wire and recoverable on demand, which is a different and much safer design than summarising context and throwing the original away.

History summarisation on a budget you set

Turns beyond a recent window get summarised once your context budget fills. The distinction Paritok draws is that its trigger is a number you choose, not the moment the model runs out of room. Anyone who has watched Claude Code auto-compact in the middle of a refactor knows why that matters.

An open 4B model you can run on an 8GB card

The compression model is about 2.5GB at Q4 quantisation, and the tool filter runs on CPU with no GPU at all. So the self-hosted path is not theoretical. You need a spare 8GB card for the compression half and nothing special for the filtering half.

Does Paritok cost you correctness?

Yes, and the company publishes the number, which we did not expect.

Paritok’s benchmark table runs SWE-bench Lite end to end: an agent scaffold gets its context through each compressor, then attempts the issue. Paritok-4B-v1 retains 86.5% of the uncompressed baseline solve rate at a 25.7% compression rate. The comparison row, gpt-4.1-mini used as a prompt compressor, retains 85.6% at 50.2%. So Paritok compresses roughly twice as hard for a slightly better solve rate, with open weights instead of closed and no per-token fee.

Read the first number again though. 86.5% quality retained means about one in seven problems the uncompressed agent solved, the compressed one did not. That is a real cost, and it is the thing to weigh against a 54% smaller bill. Paritok’s defence is that the benchmark runs with recall disabled, so it is the floor rather than the ceiling, and the deployed gateway can pull original bytes back. That is a reasonable argument. It is also unverified, because there is no published benchmark of the gateway with recall on.

How much does Paritok cost?

Self-hosting is free forever under Apache-2.0, and the hosted endpoint is $0.30 per 1M tokens, currently running at $0 as a promotion until the end of August. Both tiers get the same gateway and the same GitHub and Discord support. There is no seat pricing, no enterprise tier and no contact-us wall, which is worth saying out loud given how many tools in this category publish nothing at all.

Compare that to what it replaces. LLMLingua-2 is free and MIT licensed but compresses at roughly 40% with no agent training and no identifier preservation. Using gpt-4.1-mini as a prompt compressor costs you a second model call on every turn. Against those, $0.30 per 1M tokens to have someone else run the GPU is cheap, and free-if-you-have-the-hardware is cheaper.

The honest caveat: nobody has paid the $0.30 rate yet, because the promotion has been running since launch. A price that has never been charged is a price that can still change.

How much does Paritok actually save?

Paritok publishes a session table, and the shape of it is the useful part. One turn saves 25% and $0.073. Five turns, 39% and $0.197. Ten turns, 54% and $0.413. Twenty turns, 63% and $0.816. The curve climbs because history accumulates and gets re-sent, so the longer a session runs the more comes off.

The ceiling depends on your setup. A default agent with about 40 tools plateaus around 72%. An MCP-heavy setup with 70 or more tools reaches 78%. A context-saturated session, the kind where an agent would normally compact, gets past 85%. Their calculator, set to five developers at 120 turns a day on five-turn sessions, returns $6,550 saved a year against a $12,198 input bill.

Treat all of that as a vendor model, not a measurement. Every figure rests on assumptions you have to accept: a 96,500-token average request, $3 per 1M input, caching priced at 0.1x on both sides. Change the average request size and the whole table moves. We could not find any third-party reproduction of these numbers, and at four weeks old there has not been time for one.

Who is Paritok best for?

Use Paritok if you or your team run a coding agent for hours a day, especially with a pile of MCP servers attached. The savings scale with tool count and session length, so the heaviest users get the most. Use it if you keep hitting context limits mid-task, because fitting 44 turns into a 200K window instead of 15 changes how you work, separately from what it costs.

Use it if you can self-host. Free plus Apache-2.0 plus running on your own hardware means no vendor in your request path and no data leaving your network for the compression step.

Skip Paritok if your agent work is occasional. At one turn you save seven cents, and adding a proxy to your critical path for that is not a trade worth making. Skip it if you are working on code where a one-in-seven drop in first-pass solve rate is expensive, like a migration you cannot easily verify. And skip it if you are not allowed to run unaudited infrastructure between your team and a model provider, because a four-week-old project with 970 stars has not been through anyone’s security review yet.

Best Paritok alternatives

Prompt caching from the provider. Anthropic and OpenAI both discount repeated prefixes, and it costs nothing to turn on. It does not shrink anything, so it helps with the tool block and stable history and does nothing for the file reads that grow every turn. Free, and it stacks with Paritok rather than competing.

LLMLingua-2. Microsoft’s prompt compressor, MIT licensed and free. It is general purpose rather than code-native, compresses at roughly 40% by Paritok’s own table, and does not preserve identifiers, which is the property that matters most when the payload is source code. Fine for compressing documents, weak for agent trajectories.

Just using a cheaper model. The unglamorous option. Routing routine turns to Haiku or Flash cuts the bill more than 54% and needs no new infrastructure. It also changes what your agent can do, which compression does not. Worth trying first, because if it works you are done.

Final verdict: is Paritok worth it?

Paritok is the most honest tool we have reviewed this month. It publishes its own quality regression, names the benchmark, states that the headline figure runs with recall disabled, and prices the hosted version at a flat rate with the self-hosted version free. The engineering is thoughtful in the places that betray whether someone has actually run agents at scale: freezing the tool block for cache stability, triggering summarisation on a budget rather than an overflow, and making every compressed segment recoverable rather than gone.

What holds it back is age and evidence. One repo, four weeks old, 970 stars, no independent reproduction of a savings model built entirely on the vendor’s own assumptions, and a headline price nobody has paid yet. The 13.5% solve-rate cost is real and you should decide whether you can absorb it before you route production work through this. If you run agents heavily and can self-host, install it today and measure your own bill for a week. If you are deciding for a team, wait for someone outside the company to reproduce the benchmark. 8/10.