Supercharging your building in the AI era

Paritok drops in and non-destructively compresses tools, files, and history on the fly for longer sessions and smaller bills.

Self-host free

content removed

tool schema / turn

by turn five

self-hosted

agent → paritok → anthropicraw

segment tokens3,000100%

[SEG kind=file_read] src/payments/refund.py

from .errors import InvalidRefund

def process_refund(order_id, amount, reason=None):

"""Refund a paid order and release the hold.

Args:

order_id: primary key of the order to refund.

amount: value to return, capped at the order total.

reason: optional free-text note stored on the refund.

"""

# the order has to be paid before we can refund anything

order = Order.objects.get(id=order_id)

if order.status != 'paid':

logger.warning('refund on unpaid order %s', order_id)

raise InvalidRefund(order_id)

logger.info('refunding %s of %s', amount, order.total)

return gateway.refund(order.charge_id, amount)

… 118 more lines in this segment

read_original("a41") → the exact bytes, no extra turn

The gateway

One environment variable

That is the entire integration.

export ANTHROPIC_BASE_URL=http://127.0.0.1:8080

agent

paritok

anthropic

Your agent sends

Tool schemas, history, file reads. Unchanged.

Paritok rewrites

Filters, compresses, summarizes. Tags everything it touches.

Upstream bills less

Response comes back untouched. Refs expand on demand.

Works today withClaude CodeCursorCodexOpenHandsany OpenAI-compatible upstream

How it saves

Three levers stack.

tools[] block29Ktokens

read_filewrite_fileedit_filebashgrepgloblsweb_searchweb_fetchtodo_writetasknotebook_editslack_postslack_searchslack_usersgh_pr_creategh_issue_creategh_reviewjira_createjira_searchlinear_issuenotion_pagenotion_db_queryfigma_filedrive_listsheets_readcalendar_listgmail_searchsentry_issuesdatadog_querypagerduty_incidentstripe_chargestripe_refundaws_s3_listaws_lambda_invokegcp_bucketk8s_get_podsk8s_logsdocker_pspostgres_queryredis_getmongo_findbrowser_clickbrowser_snapshotmemory_writevector_query

46 schemas, every one sent in full, every single turn

Tool schemas

29K → 8Kper turn

Agents ship 70+ tools in full JSON on every request. We keep the relevant ones, stub the rest.

Frozen per conversation, so the block stays cache-stable.

segments13,220tokens

file_read refund.py4,820

tool_result pytest -q2,140

log_output worker.log3,360

file_read orders.py2,900

every read and tool result, at full size

File reads & output

26%of original

Our 4B model knows a function signature from a debug line. Identifiers, paths and errors survive.

Small per turn. Compounds hard across a session.

context windowfilling

summary

turn 1turn 2turn 3turn 4turn 5turn 6turn 7turn 8

turns accumulate, every one re-sent

Stale history

0overflows

Turns beyond a recent window get summarized once your context budget fills. Recent turns are left untouched.

Ours runs on a budget you set, not when the model runs out of room.

read_original(ref)gateway_search_tools(q)

Nothing is ever discarded

Lossy on the wire, recoverable when it counts. The agent asks for the exact bytes and gets them — locally, without burning a turn.

Built with Paritok

People build on Paritok

Three winning projects from the token-efficiency hackathon.

Head-to-head, same repo

Dragstrip

Races the same coding agent with and without Paritok on any GitHub repo, then has a blind judge score both answers.

Ajay Prakash

FastAPI · Gemini · SSE

12–52% end to end, measured

Headroom

A coding agent held to a 32,768-token ceiling, with a harness comparing truncation, pagination and compression at identical fix quality.

Shivang Shirodkar

Python · GLM-5.1 · Apache-2.0

15 turns → 250 alive

Paritok's Labyrinth

A roguelike where your health bar is your token budget. Compressing the dungeon state refunds the savings as health.

Subhranil Mondal

FastAPI · NVIDIA NIM

Compounding

Use more, save more

Every file you read stays in history and is re-sent. So compression keeps paying, turn after turn.

Across a session

The longer it runs, the more comes off

sessioncontextsharesaved

1 turn

40K → 12K

25%$0.073

5 turns

84K → 30K

39%$0.197

10 turns

140K → 52K

54%$0.413

12 turns

162K → 60K

57%$0.497

15 turns

195K → 73K

60%$0.618

20 turns

250K → 95K

63%$0.816

Saved across the whole session, against an average 96,500-token request at $3 / 1M with caching priced into both sides at 0.1×.

Your ceiling

How high it goes depends on your setup

setupceilingsaved / turn

Default · ~40 tools72%$0.039

96,500 tokens / turn

MCP-heavy · 70+ tools78%$0.048

127,500 tokens / turn

Context-saturated85%+$0.069+

200,000 tokens / turn · where a no-Paritok session compacts

Your numbers

Put your own volume in

Developers5

Turns per developer, per day120

Typical session length

Your setup

Context window

Your model

$6,550

saved per year · estimate

Input bill without Paritok$12,198

Input bill with Paritok$5,648

Share of the bill removed54%

Plateau, from turn ~872%

Turns that fit in 200K15 → 44

Work before you hit a limitsubscription plans — a seat meters on usage, not dollars1.9×

The engine

Code-native 4B compression model

45K real agent trajectoriesApache-2.0

Compressor	Quality retained	Compression rate	Agent-trained	Keeps identifiers	Weights	Per-token fee
Uncompressed baseline	100.0%	100.0%	✕	—	n/a	free
LLMLingua-2	not evaluated	~40.0%	✕	◑	MIT	free
gpt-4.1-mini (prompt)	85.6%	50.2%	✕	◑	closed	paid
Paritok-4B-v1⭐	86.5%	25.7%	✓	✓	Apache-2.0	free

SWE-bench Lite, end-to-end: an agent scaffold receives its context through each compressor, then attempts the issue. Quality retained = solve rate ÷ uncompressed baseline. Compression rate is lower-is-harder.

The benchmark is a floor, not a ceiling

That 86.5% is the raw model with recall disabled — the honest, reproducible floor. What you deploy is the gateway, where every segment is tagged and read_original pulls back anything the benchmark left on the table.

Weights Training pipeline

Pricing