Kosten besparen op coding agents met Paritok

Wat Paritok doet met een verzoek

Paritok is een token-gateway: een proxy die zich tussen uw coding agent en de model-API bevindt en elk verzoek comprimeert voordat het wordt doorgestuurd. Uw agent communiceert met http://127.0.0.1:8080 in plaats van met de provider. De proxy herschrijft de tool-schema's, de bestand-reads, de tool-output en de oudere turns, verstuurt de kleinere payload naar de upstream en geeft het antwoord ongewijzigd terug.

De provider brengt kosten in rekening voor wat er bij de provider aankomt, dus een kleinere payload betekent een lagere factuur. Dat is het hele idee. Dit is een andere claim dan "uw context gaat langer mee", en het is de reden waarom deze tool interessant is in plaats van alleen netjes.

Het project is jong. De eerste publieke tags dateren van juli 2026 en de huidige tag is v1.3.0, gedateerd 5 augustus 2026. De gewichten en de gateway-code vallen onder de Apache 2.0-licentie. Het compressiemodel is een LoRA (low-rank adaptation) adapter op Qwen3-4B-Instruct-2507, getraind op 45.000 door docenten gedestilleerde samples afkomstig van trajecten van echte coding agents.

Waarom dit geen context-trimming is

Trimming verwijdert gegevens. Wanneer een agent zijn contextlimiet nadert en de oudste interacties verwijdert, is het bestand dat bij interactie 3 werd gelezen verdwenen. Als de agent dat bestand bij interactie 20 nodig heeft, moet het bestand opnieuw worden gelezen, waardoor u die tokens een tweede keer betaalt. De besparing was in feite een lening.

Paritok vervangt een segment door een kortere vorm met een tag, [REF:id], en bewaart de volledige tekst op de proxy. Het model herstelt een segment door read_original of expand_context aan te roepen. Dat verandert de wijze van falen. Een trimmer faalt door te vergeten, zonder dat u daarvan op de hoogte wordt gesteld. Een compressor faalt door het model een verliesgevende samenvatting te geven, waarbij het model om het origineel kan vragen wanneer de samenvatting niet volstaat.

Het tool-filter gedraagt zich op dezelfde manier. Gefilterde tool-schema's worden vervangen door een stub in plaats van verwijderd, en het model herstelt er een door gateway_search_tools aan te roepen. Dit is van belang omdat een filter dat een tool permanent verbergt, de mogelijkheden van uw agent verandert; u zou dit pas merken via een taak die stilletjes mislukt.

De drie hefbomen, en welke daarvan gratis is

Hefboom één is het tool-schemafilter. Elk verzoek bevat de volledige tools array. Bij een Claude Code-sessie met enkele gekoppelde MCP (model context protocol)-servers, meet het project dat blok op ongeveer 29.000 tokens. Het filter zet het verzoek van de gebruiker en elke toolbeschrijving om in embeddings met BAAI/bge-small-en-v1.5, een embedding-model van 130 MB. Het behoudt de tools die overeenkomen en vervangt de rest door stubs. Het blok krimpt hierdoor tot ongeveer 8.000 tokens. Dat embedding-model draait op de CPU.

Hefboom twee is inhoudscompressie, en dit is het onderdeel waarvoor het 4B-model op een GPU nodig is. Bestandlezingen, tool-output en de geschiedenis worden herschreven naar 25,7% van hun oorspronkelijke omvang. Dat is waar het cijfer van 74% vandaan komt. Lees dit zorgvuldig: 74% is de compressieratio van de inhoud die wordt gecomprimeerd, niet de besparing op uw factuur.

Hefboom drie is het samenvatten van de geschiedenis. Zodra het contextbudget vol is, worden beurten buiten het recente venster samengevat, zodat een lange sessie door kan blijven lopen in plaats van de limiet te bereiken.

Alleen hefboom twee vereist een GPU. Dat is de meest nuttige zin op deze pagina. pip install "paritok[toolselect]" biedt u het toolfilter op een standaard CPU VPS, en dit is de helft van het product die u maandelijks niets kost. Probeer dit uit voordat u een kaart huurt.

Wat het project heeft gemeten en op welke testomgeving

[
  {
    "label": "Paritok-4B-v1",
    "compressed_to_pct": 25.7,
    "quality_retained_pct": 86.5
  },
  {
    "label": "gpt-4.1-mini",
    "compressed_to_pct": 50.2,
    "quality_retained_pct": 85.6
  },
  {
    "label": "gpt-5",
    "compressed_to_pct": 61.9,
    "quality_retained_pct": 93.6
  }
]

Dit zijn de door het project zelf gepubliceerde cijfers, gemeten op de eigen testomgeving tegen SWE-bench Lite. Paritok-4B-v1 comprimeert inhoud tot 25.7% van de oorspronkelijke grootte, terwijl 86.5% van het oplossingspercentage van de ongecomprimeerde versie behouden blijft. Het gebruik van gpt-5 als compressor behoudt meer kwaliteit, 93.6%, maar comprimeert slechts tot 61.9%, en u betaalt dan prijzen voor frontier-modellen om prijzen voor frontier-modellen te besparen.

Lees de kwaliteitskolom kritisch. Het behouden van 86,5% van het oplossingspercentage betekent dat de gecomprimeerde runs problemen niet konden oplossen die de ongecomprimeerde runs wel oplosten; dit komt neer op bijna één op de zeven opgeloste problemen. In een benchmark is dat een getal in een tabel. In uw repository is het een taak die u twee keer moet uitvoeren.

[
  {
    "label": "Turn 1",
    "saved_pct": 25
  },
  {
    "label": "Turn 5",
    "saved_pct": 39
  },
  {
    "label": "Turn 12",
    "saved_pct": 57
  },
  {
    "label": "Turn 20",
    "saved_pct": 63
  }
]

De end-to-end besparing groeit naarmate een sessie vordert, omdat de geschiedenis zich opbouwt en de geschiedenis hetgeen is dat wordt gecomprimeerd. Het project rapporteert ongeveer 25% bij een enkele beurt, 39% bij beurt 5 en 63% bij beurt 20. Het vermeldt ook waar de groei stopt: bij een budget van 200.000 tokens vlakt de absolute besparing af op ongeveer 48.000 tokens per beurt, ergens rond beurt 8 tot 12, omdat de geschiedenis niet meer groeit zodra de context vol is. Het veel geciteerde cijfer van "ruim 85%" beschrijft sessies met een verzadigde context. Dat is het best-case scenario, dus plan uw werkzaamheden hier niet op.

Is een 24GB GPU rendabel voor Paritok?

Een kaart met 24 GB is de standaard verhuureenheid voor een model van deze omvang. Op 7 augustus 2026 bedroeg het mediane on-demand tarief voor een RTX 4090 met 24 GB $0,44 per uur, waarbij de goedkoopste aanbiedingen rond de $0,20 lagen. Laten we uitgaan van $0,44. Bij continu gebruik gedurende de hele maand (730 uur) komt dit neer op $321. Bij gebruik tijdens kantooruren, 8 uur per dag gedurende 22 dagen, is dit 176 uur, oftewel $77.

Vertaal nu de tokenbesparing naar een geldbesparing. De reductie is van toepassing op input-tokens. Output-tokens passeren de proxy ongewijzigd en veranderen dus niet. Ga ervan uit dat input-tokens 80% van uw totale kosten beslaan, wat gebruikelijk is voor een coding agent, en controleer deze aanname aan de hand van uw eigen factuur. Uw geldbesparing is dan de tokenreductie vermenigvuldigd met 0,8.

[
  {
    "label": "Turn 5 (39% saved)",
    "bill_always_on_usd": "1,030",
    "bill_workday_only_usd": 248
  },
  {
    "label": "Turn 20 (63% saved)",
    "bill_always_on_usd": 637,
    "bill_workday_only_usd": 154
  },
  {
    "label": "Saturated (85% saved)",
    "bill_always_on_usd": 472,
    "bill_workday_only_usd": 114
  }
]

Bij een verzadigde sessie van 85% bespaart u 68% op de factuur. Een kaart die altijd aan staat, verdient zichzelf terug zodra uw maandelijkse uitgaven aan de agent de grens van ongeveer $472 overschrijden, of ongeveer $114 als u de instantie buiten kantooruren stopt. Bij een turn-20-cijfer van 63% worden dit $637 en $154. Bij een turn-5-cijfer van 39%, wat de realiteit is bij korte sessies, heeft u ongeveer $1,030 per maand nodig voordat het huren van de kaart überhaupt rendabel is.

Twee factoren maken dit gunstiger dan de tabel suggereert. Het model heeft geen 24 GB nodig: de q4-build is ongeveer 2,5 GB en de bf16-build ongeveer 8 GB. Een kleinere kaart, of een GPU-server die u al voor andere doeleinden gebruikt, verlaagt elk getal in die tabel. Daarnaast is het stoppen van de instantie wanneer er niet geprogrammeerd wordt de belangrijkste factor, omdat dit de huurkosten met ongeveer driekwart verlaagt.

Eén factor maakt het ongunstiger. De compressiefase vereist rekenkracht. Elk token dat het 4B-model comprimeert, moet worden gelezen en vervolgens geschreven, wat latentie toevoegt aan elke agent-turn. Bij een kaart die u per uur huurt, uit deze kosten zich in wachttijd in plaats van als een post op een factuur, waardoor het makkelijk over het hoofd wordt gezien totdat u het merkt.

Als u de afweging maakt tussen gehuurde GPU-uren en API-tokens in het algemeen, hanteert het break-even punt tussen een GPU VPS en API-tokens dezelfde berekening voor inferentie zelf.

De Paritok gateway draaien op een VPS

Python 3.10 of nieuwer is vereist. Ubuntu 24.04 wordt geleverd met Python 3.12, dus een standaard VPS-image volstaat voor de CPU-only helft.

sudo apt update && sudo apt install -y python3-venv curl
python3 -m venv /opt/paritok/venv
source /opt/paritok/venv/bin/activate
pip install "paritok[proxy]==1.3.0"
pip install "paritok[toolselect]==1.3.0"

Zet de versie vast. De repository kreeg op 29 juli 2026 de tag v1.2.8 en op 5 augustus 2026 v1.3.0; een project dat in dit tempo ontwikkelt, wijzigt configuratiesleutels tussen releases. Een kale pip install paritok, of een git clone van main, levert u volgende week een andere gateway op en laat geen spoor na van welke versie de door u gemeten cijfers heeft geproduceerd.

De standaard backend is Ollama. Haal het model op en geef het de korte naam waar de proxy naar zoekt.

ollama pull paritok/paritok-4b-v1
ollama cp paritok/paritok-4b-v1 paritok-4b-v1

Schrijf paritok.yaml ernaast. use_gpu_server: false zorgt ervoor dat de compressie op uw eigen hardware blijft.

use_gpu_server: false
local_model:
  base_url: http://localhost:11434

paritok proxy --port 8080 --config-file paritok.yaml

paritok up is de snelkoppeling voor al het bovenstaande: het haalt het model op als het ontbreekt en start de proxy op poort 8080. Controleer de proxy voordat u er een agent naar verwijst.

curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/stats

/health retourneert een klein JSON-object met "status":"ok" en een versiereeks. /stats retourneert compressietotalen en de eigen schatting van de proxy van de besparing. Beschouw deze schatting als de proxy die zijn eigen werk beoordeelt en verifieer dit aan de hand van de verbruikspagina van uw provider.

Voor doorvoer in plaats van gemak serveert vLLM de adapter bovenop het basismodel.

vllm serve Qwen/Qwen3-4B-Instruct-2507 \
  --enable-lora \
  --lora-modules paritok-4b-v1=paritok/paritok-4b-v1 \
  --port 8000

Ollama is sneller op te zetten. vLLM verwerkt gelijktijdige verzoeken veel beter, wat van belang wordt zodra meer dan één agent de server deelt. Het praktische verschil tussen Ollama en vLLM is wat hier de doorslag geeft.

Verwijs de agent naar de proxy met de omgevingsvariabelen voor de basis-URL.

export ANTHROPIC_BASE_URL=http://127.0.0.1:8080
export OPENAI_BASE_URL=http://127.0.0.1:8080

Codex CLI negeert OPENAI_BASE_URL, dus het project schrijft ~/.codex/config.toml voor u wanneer codex.enabled: true is ingesteld in paritok.yaml. Het exporteren van de variabele op zichzelf zorgt ervoor dat Codex rechtstreeks met de provider communiceert; het teken daarvan is een /stats-teller die nooit beweegt terwijl u werkt.

Houd de listener op 127.0.0.1, nooit op 0.0.0.0. De proxy stuurt uw API-sleutel van de provider door naar de upstream, dus een proxy die bereikbaar is vanaf het internet is een open relay voor die sleutel: wie de poort vindt, geeft uw geld uit zonder de sleutel zelf ooit te zien. Benader deze vanaf een laptop via een SSH-tunnel of een VPN in plaats van de poort open te stellen.

Draai het onder systemd zodat het een herstart overleeft. Pas de paden aan uw installatie aan.

[Unit]
Description=Paritok compression proxy
After=network-online.target

[Service]
User=paritok
WorkingDirectory=/opt/paritok
ExecStart=/opt/paritok/venv/bin/paritok proxy --port 8080 --config-file /opt/paritok/paritok.yaml
Restart=on-failure

[Install]
WantedBy=multi-user.target

Schakel het in met sudo systemctl enable --now paritok en voer daarna opnieuw /health uit met curl. Een unit die start en direct weer afsluit, betekent meestal dat het pad naar het configuratiebestand onjuist is, en journalctl -u paritok -n 50 toont de reden.

De gehoste optie en de bijbehorende kosten

Het project biedt de compressie ook aan als een dienst. Stel use_gpu_server: true in met een API key en het 4B-model draait op hun hardware. De prijs hiervoor is $0.30 per miljoen verwerkte tokens; volgens de eigen documentatie is dit gratis tot eind augustus 2026. Hiermee vervallen de kosten voor GPU-huur en al het bovenstaande operationele werk.

Dit betekent echter ook dat uw prompts en de bestanden die uw agent leest uw machine verlaten en een derde partij bereiken voordat ze bij uw modelprovider aankomen. Self-hosting bestaat juist om die tussenstap te vermijden. Bepaal voor welke van de twee u kiest voordat u die flag instelt, want de flag is een wijziging van één regel, maar de consequenties zijn dat niet.

Hoe u uw eigen resultaten voor en na de wijziging meet

De gepubliceerde cijfers zijn de cijfers van het project zelf, afkomstig uit de testomgeving van het project op SWE-bench Lite. Uw repository is geen SWE-bench Lite. Meet daarom uw eigen resultaten.

• Draai één normale week zonder proxy in het pad. Noteer input-tokens, cache-read-tokens en output-tokens als afzonderlijke regels vanaf de verbruikspagina van uw provider, niet als één totaalbedrag in dollars.
• Draai de week daarna met de proxy ervoor, terwijl u hetzelfde type werk uitvoert.
• Vergelijk de regels voor input en cache-read. De output zou ongeveer gelijk moeten blijven, omdat deze niet wordt gecomprimeerd. Als de output sterk is veranderd, is er iets anders dan de proxy gewijzigd.
• Tel het aantal taken dat u opnieuw moest uitvoeren. Dat is de kwaliteitshelft van de afweging, en geen enkel dashboard rapporteert dit.
• Tel de GPU-uren op bij week twee voordat u de totalen vergelijkt.

Het splitsen van input en output is van belang omdat beide zeer verschillend geprijsd zijn en een compressor slechts op één van beide invloed heeft. Per augustus 2026 kost Claude Sonnet 4.6 $3 per miljoen input-tokens en $15 per miljoen output-tokens, en een prompt-cache read kost 10% van het input-tarief, oftewel $0,30 per miljoen. Het verschil tussen de kosten voor input- en output-tokens bepaalt of een compressor aan de input-zijde voor u de moeite waard is. Waar de tokens van Claude Code daadwerkelijk naartoe gaan geeft aan welk deel van uw context groot genoeg is om te comprimeren.

Prompt-caching maakt de berekening voor tool-filtering in het bijzonder complex. Het tool-blok bevindt zich aan het begin van het verzoek, dus na de eerste beurt is het normaal gesproken een cache-hit tegen 10% van de input-prijs. Het verwijderen van 21.000 tokens uit een gecachet blok bespaart 21.000 tokens tegen $0,30 per miljoen, ongeveer $0,006 per beurt, in plaats van de $0,063 die het niet-gecachete tarief zou suggereren. Het project houdt het gefilterde blok bevroren voor de sessie, zodat het gecachete voorvoegsel niet verandert. Een filter dat bij elke beurt opnieuw tools zou selecteren, zou dat voorvoegsel ongeldig maken en meer kosten dan het bespaart.

Wat nog niet is geverifieerd

Elk prestatiecijfer hierboven is afkomstig van het project zelf. Er is geen onafhankelijke reproductie van de SWE-bench Lite-resultaten, en aangezien de eerste tags dateren van juli 2026, is er ook nauwelijks operationele historie beschikbaar voor de code. Zowel de compressieratio als het cijfer voor behouden kwaliteit zijn gemeten door de partij die er baat bij heeft dat deze cijfers gunstig ogen. Dat maakt ze niet onjuist. Het maakt ze onbevestigd, en u dient ze anders te beoordelen dan cijfers die u zelf heeft gegenereerd.

Eén gedocumenteerd gedrag is het vermelden waard voordat u uw eigen configuratie de schuld geeft. Het embedding-model dat door de tool-filter wordt gebruikt, laadt bij het eerste verzoek in plaats van bij het opstarten. Daarom documenteert het project een opwarmtijd van 10 tot 15 seconden, gevolgd door ongeveer 15 ms per aanroep daarna. Verstuur één testverzoek nadat de proxy is gestart, zodat uw eerste echte agent-actie niet traag lijkt.

Vier zaken kunt u zelf in een middag vaststellen: of de proxy start en actief blijft, of /stats verandert terwijl u werkt, of de input-token-lijn van uw provider daadwerkelijk daalt, en of de agent het werk nog steeds voltooit. Deze factoren zijn voor uw configuratie veel bepalender dan welke gepubliceerde benchmark dan ook.

Wat betreft de positie ten opzichte van uw overige tooling: een self-hosted LiteLLM gateway routeert en meet verzoeken zonder de inhoud ervan te wijzigen. De twee lossen dus verschillende problemen op en kunnen achter elkaar worden geschakeld, waarbij Paritok zich het dichtst bij de agent bevindt. Als het werkelijke doel een lagere rekening is in plaats van deze specifieke tool, bevat de bredere set kostenbeheersingsmaatregelen voor een agent op een VPS diverse wijzigingen die niets kosten om eerst te proberen.

FAQ

Verlaagt Paritok mijn API-rekening of alleen mijn contextgebruik?

Het verlaagt de rekening, omdat de proxy het verzoek herschrijft voordat het de provider bereikt en de provider kosten in rekening brengt voor wat deze ontvangt. De omvang van die besparing is kleiner dan de kop suggereert. Het cijfer van 74% is de compressieratio van de inhoud die wordt gecomprimeerd. Van begin tot eind rapporteert het project ongeveer 25% bij een enkele beurt en 63% bij beurt 20, en alleen input-tokens worden aangepast. Output-tokens worden ongewijzigd doorgelaten.

Hoeveel GPU heb ik nodig om het compressiemodel zelf te hosten?

De q4-build is ongeveer 2,5 GB en de bf16-build ongeveer 8 GB, dus het model past in een 24 GB-kaart met veel resterende ruimte. Een kleinere kaart werkt ook, en dat verandert de break-even-berekening in uw voordeel. Het tool-schema-filter heeft helemaal geen GPU nodig: het gebruikt BAAI/bge-small-en-v1.5, een 130 MB embedding-model dat op de CPU draait. Installeer paritok[toolselect] op een standaard VPS en u krijgt de tool-block-reductie voor de prijs van een beetje RAM.

Wat gebeurt er als de compressor iets verwijdert dat de agent nodig had?

Er wordt niets verwijderd. Gecomprimeerde segmenten dragen een [REF:id]-tag en het model herstelt de volledige tekst met read_original of expand_context. Gefilterde tool-schema's worden vervangen door stubs in plaats van verwijderd, en het model herstelt er een met gateway_search_tools. Het werkelijke risico is subtieler dan een ontbrekend bestand: het model werkt op basis van een verlieslatende samenvatting en realiseert zich nooit dat het om het origineel moet vragen. Dat is wat het cijfer van 86,5% behouden kwaliteit op SWE-bench Lite meet.

Waarom duurt mijn eerste verzoek vijftien seconden?

Het embedding-model achter het tool-filter wordt bij het eerste verzoek geladen in plaats van bij het opstarten. Het project documenteert een opwarmtijd van 10 tot 15 seconden, en daarna ongeveer 15 ms per aanroep. Verstuur één wegwerpverzoek met curl na het starten van de proxy, dan zal de eerste echte agent-beurt niet vertragen.

Moet ik de gehoste GPU-server gebruiken in plaats van zelf-hosting?

Het elimineert de GPU-huur en het onderhoud, geprijsd op $0,30 per miljoen verwerkte tokens per augustus 2026. Het verstuurt echter ook uw prompts en de bestanden die uw agent leest naar een derde partij voordat ze uw modelprovider bereiken. Als u zelf-host om code op infrastructuur te houden die u beheert, maakt die instelling de reden waarom u begon ongedaan. Zelf-hosting houdt zowel de context als de API-sleutel van de provider op uw eigen systeem.