Paritok réduit-il vraiment la facture de votre agent ?
Paritok compresse les lectures de fichiers et sorties d’outils. Le projet annonce 74 % de tokens en moins : découvrez le mécanisme et le seuil de rentabilité.
Ce que Paritok fait à une requête
Paritok est une passerelle de tokens : un proxy qui se place entre votre agent de code et l’API du modèle, puis compresse chaque requête avant de la transmettre. Votre agent communique avec http://127.0.0.1:8080 au lieu du fournisseur. Le proxy réduit les schémas des outils, les lectures de fichiers, les sorties des outils et les anciens tours de conversation, envoie la charge utile réduite au fournisseur, puis renvoie la réponse sans la modifier.
Le fournisseur vous facture ce qui lui parvient, mais la facture dépend des tokens supprimés, de leur tarification de cache et du nombre de tours effectués par l’agent. C’est tout le principe. Cette affirmation est différente de « votre contexte dure plus longtemps » et c’est ce qui rend cet outil intéressant, plutôt qu’un simple outil de nettoyage.
Le projet est récent. La passerelle a été publiée en open source le 15 juillet 2026. PyPI date la version v1.3.14 du 6 octobre 2026 et la version v1.3.0 du 5 août. Les poids et le code de la passerelle sont sous licence Apache 2.0. Le modèle de compression est un adaptateur LoRA (low-rank adaptation) basé sur Qwen3-4B-Instruct-2507. Il a été distillé à partir d’un ensemble de 45,000 segments extraits de trajectoires réelles d’agents de code, dont 40,606 ont passé la validation du teacher et sont devenus les exemples d’entraînement.
Pourquoi il ne s’agit pas d’une réduction du contexte
La réduction supprime définitivement les données. Lorsqu’un agent approche de sa limite de contexte et supprime les tours les plus anciens, le fichier qu’il a lu au tour 3 disparaît. S’il a besoin de ce fichier au tour 20, il le relit et vous payez une deuxième fois pour ces tokens. L’économie n’était qu’un prêt.
Paritok remplace un segment par une forme plus courte accompagnée d’une balise, [REF:id], et conserve le texte complet sur le proxy. Le modèle récupère un segment en appelant read_original ou expand_context. Le mode d’échec change. Un outil de réduction échoue en oubliant des informations, sans jamais vous le signaler. Un outil de compression échoue en transmettant au modèle un extrait avec perte, mais le modèle peut demander l’original lorsque l’extrait ne suffit pas.
Les schémas d’outils filtrés restent récupérables, mais le filtre adaptatif par défaut supprime les outils standard non sélectionnés et les outils MCP non sélectionnés, sauf si son signal de pertinence MCP se déclenche. Lorsque ce signal se déclenche, les outils MCP non sélectionnés sont remplacés par des stubs. gateway_search_tools permet la récupération, et la gateway détecte également les messages signalant un outil manquant, puis injecte les outils correspondants avant de réessayer. C’est important, car un filtre qui masque définitivement un outil modifie ce que votre agent est capable de faire. Vous ne le découvririez qu’à l’occasion d’une tâche qui échouerait discrètement.
Les trois leviers, et celui qui est gratuit
Le premier levier est le filtre de schémas d’outils. Chaque requête contient l’intégralité du tableau tools. Lors d’un tour Claude Code sans serveur MCP (model context protocol) associé, le projet évalue ce bloc à environ 29,000 tokens. Avec MCP, il indique entre 44,000 et 65,000 tokens. Le filtre encode la requête de l’utilisateur et la description de chaque outil avec BAAI/bge-small-en-v1.5, un modèle d’embeddings de 130 MB. Il conserve les outils correspondants, supprime les outils standard non sélectionnés et ne remplace les outils MCP non sélectionnés par des stubs que lorsque son signal de pertinence MCP se déclenche. Sinon, il supprime également ces outils MCP. Dans l’exemple du projet à 29,000 tokens, le bloc passe à environ 8,000 tokens. Ce modèle d’embeddings s’exécute sur le CPU.
Le deuxième levier est la compression du contenu. C’est cette partie qui utilise le modèle 4B, sur un GPU ou via Ollama sur le CPU. Les lectures de fichiers, la sortie des outils et l’historique sont réduits à 25.7 % de leur taille d’origine. Le modèle sélectionne principalement des segments au lieu de les réécrire. La réécriture reste possible dans certains cas, notamment pour les résumés du raisonnement et la structure des appels d’outils. L’article du projet mesure que 96.0 % des identifiants, chemins et nombres produits apparaissent textuellement dans l’entrée du corpus d’entraînement généré par l’enseignant. La sortie du modèle entraîné sur l’ensemble de test SWE-bench Lite obtient 96.2 % lors du même audit. C’est de là que vient le chiffre de 74 %. Interprétez-le correctement : 74 % est le taux de compression du contenu compressé, et non la réduction de votre facture.
Le troisième levier est le résumé de l’historique. Par défaut, lorsque le contexte dépasse 80 % de la fenêtre configurée, les anciens tours sont résumés. Les quatre tours récents restent intacts. Une longue session peut ainsi continuer au lieu d’atteindre la limite.
Un GPU est facultatif pour l’auto-hébergement. C’est la phrase la plus utile de cette page. pip install "paritok[toolselect]" vous fournit le filtre d’outils sur un VPS CPU ordinaire, sans frais par token. Essayez-le avant de louer une carte.
Ce que le projet a mesuré, et avec quel harness
Les données de ce graphique
[
{
"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
}
]Il s’agit des chiffres publiés par le projet, mesurés avec son propre harness sur SWE-bench Lite. Paritok-4B-v1 réduit le contenu à 25.7% de sa taille d’origine tout en conservant 86.5% du taux de résolution sans compression. Utiliser gpt-5 comme compresseur conserve davantage de qualité, soit 93.6%, mais réduit seulement le contenu à 61.9%. Vous paieriez alors des tarifs frontier pour économiser sur des tarifs frontier.
Interprétez honnêtement la colonne de qualité. La qualité conservée correspond au taux de résolution avec compression divisé par le taux de résolution de référence sans compression. Conserver 86.5% signifie une réduction nette de 13.5% du nombre de résolutions par rapport à cette référence. Cela ne correspond pas à la proportion des problèmes résolus dans la référence qui ont été perdus, car les exécutions avec compression peuvent aussi résoudre d’autres problèmes. Cette mesure évalue la compréhension en single-shot d’un code source brut compressé, avec le recall désactivé et la récupération des modifications en production activée. Elle ne mesure ni le filtre CPU du tool schema ni le gateway multi-tour complet.
Les données de ce graphique
[
{
"label": "Turn 1",
"saved_pct": 25
},
{
"label": "Turn 5",
"saved_pct": 39
},
{
"label": "Turn 12",
"saved_pct": 57
},
{
"label": "Turn 20",
"saved_pct": 63
}
]L’économie de bout en bout augmente au fil de la session, car l’historique s’accumule et c’est lui qui est compressé. Le projet indique environ 25% sur un seul tour, 39% au tour 5 et 63% au tour 20. Seuls les tours 1 à 5 sont mesurés ; le README présente les lignes suivantes comme des projections. Il indique également où cette progression s’arrête : avec un budget de 200,000 tokens, l’économie de contenu par tour se stabilise autour de 48,000 tokens, vers le tour 8 à 12, car une fois le contexte rempli, l’historique n’augmente plus. L’économie distincte liée au tool-filter ajoute environ 21,000 tokens par tour, ce qui porte le plateau combiné projeté à environ 69,000 tokens par tour. Le chiffre souvent cité de « plus de 85% » décrit les sessions dont le contexte est saturé. Il s’agit du meilleur cas. Le même README indique que l’économie tend vers un plafond d’environ 72% avec les paramètres par défaut. Ne construisez donc pas votre plan sur ce chiffre.
Une carte graphique de 24 GB est-elle rentable pour Paritok ?
Un GPU est facultatif, et le modèle tient sur des cartes de moins de 24 GB. Pour un calcul de location indicatif, prenez $0.44 par heure pour une carte de 24 GB. Si elle reste allumée tout le mois, cela représente 730 heures, soit $321. Si vous l’exécutez uniquement pendant les heures de travail, 8 heures par jour pendant 22 jours, cela représente 176 heures, soit $77.
Convertissez maintenant la réduction de tokens en réduction de coût. La réduction s’applique aux tokens d’entrée. Les tokens de sortie traversent le proxy sans modification : le proxy ne les compresse donc pas. Évaluez séparément la variation du coût pour les nouvelles entrées, les écritures dans le cache et les lectures du cache, en utilisant les tarifs de votre fournisseur, puis comparez le coût total de l’API avant et après. Même si les entrées représentent 80% de votre coût total, multiplier une réduction de tokens par 0.8 ne permet pas d’établir l’économie réalisée sur votre facture.
Les données de ce graphique
[
{
"label": "Always on (730 hours)",
"required_api_saving_usd": 321.2
},
{
"label": "Workday only (176 hours)",
"required_api_saving_usd": 77.44
}
]Une carte laissée allumée s’amortit dès que l’économie mensuelle mesurée sur l’API dépasse $321.2, ou $77.44 si vous arrêtez l’instance en dehors des heures de travail. Une réduction de tokens de 85% ne suffit pas à établir une économie de 68% sur la facture. Elle ne permet donc pas non plus d’établir un seuil mensuel de dépenses pour l’agent. Divisez le coût de location par la fraction d’économie mesurée sur la facture pour obtenir ce seuil.
Deux éléments rendent cette solution plus intéressante que ne le suggère le graphique. Le modèle n’a pas besoin de 24 GB : le build q4 fait environ 2.5 GB et le build f16 environ 8 GB. Une carte plus petite, ou une machine GPU que vous utilisez déjà pour autre chose, réduit donc tous les montants du graphique. Ensuite, arrêter l’instance lorsque personne ne code est le levier le plus important, car cela réduit la location d’environ trois quarts.
Un élément la rend moins intéressante. La passe de compression demande réellement des ressources. Chaque token que le modèle 4B compresse doit être lu, et chaque segment conservé doit être réécrit par le modèle. Cela ajoute de la latence à chaque tour de l’agent. Avec une carte louée à l’heure, ce coût se manifeste par de l’attente et non par une ligne sur la facture. Il est donc facile de ne pas le voir avant d’en ressentir l’effet.
Si vous comparez de manière générale les heures de GPU louées au coût des tokens d’API, le seuil de rentabilité entre un GPU VPS et les tokens d’API applique le même calcul à l’inférence elle-même.
Exécuter la passerelle Paritok sur un VPS
Les métadonnées du paquet sur PyPI acceptent Python 3.10 ou une version ultérieure, même si le badge du README indique 3.11+. Ubuntu 24.04 fournit Python 3.12. Une image VPS standard suffit donc pour le filtre d’outils CPU.
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.14"
pip install "paritok[toolselect]==1.3.14"Épinglez la version. PyPI date v1.3.0 du 5 August 2026 et v1.3.14 du 6 October 2026. Un projet qui évolue à ce rythme renomme des éléments entre les releases : v1.3.0 a lui-même renommé expand_context en read_original dans son API. Un pip install paritok sans version, ou un git clone de main, peut vous fournir une passerelle différente la semaine suivante. Vous ne saurez alors plus laquelle a produit les valeurs mesurées.
Le backend par défaut est Ollama. Téléchargez le modèle, puis donnez-lui le nom court recherché par le proxy.
ollama pull paritok/paritok-4b-v1
ollama cp paritok/paritok-4b-v1 paritok-4b-v1Comme le modèle local écrit les spans conservés pour chaque segment qu’il compresse, une passe de compression trop longue se manifeste par un tour d’agent bloqué. La limite num_predict d’Ollama sur la longueur de sortie permet de la borner.
Écrivez paritok.yaml à côté. use_gpu_server: false garantit que la compression reste sur votre propre matériel.
use_gpu_server: false
local_model:
base_url: http://localhost:11434/v1paritok proxy --port 8080 --config-file paritok.yamlparitok up permet de télécharger le modèle s’il manque et de démarrer le proxy sur le port 8080. Ollama doit déjà être installé. Vérifiez le proxy avant de configurer un agent pour l’utiliser.
curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/stats/health renvoie un petit objet JSON contenant "status":"ok" et une chaîne de version. /stats renvoie les totaux de compression et l’estimation du proxy concernant le volume économisé. Considérez cette estimation comme une auto-évaluation du proxy et vérifiez-la sur la page d’utilisation de votre fournisseur.
Pour privilégier le débit, plutôt que la simplicité, vLLM sert l’adapter au-dessus du modèle de base.
vllm serve Qwen/Qwen3-4B-Instruct-2507 \
--enable-lora \
--lora-modules paritok-4b-v1=paritok/paritok-4b-v1 \
--max-lora-rank 32 \
--port 8000L’option --max-lora-rank 32 figure dans la commande propre au projet, car l’adapter utilise un rank de 32. Définissez ensuite local_model.base_url sur http://localhost:8000/v1 dans paritok.yaml afin que le proxy communique avec vLLM au lieu d’Ollama.
Ollama est plus rapide à mettre en place. vLLM gère bien mieux les requêtes concurrentes. Cela devient important dès que plusieurs agents partagent la machine. La différence pratique entre Ollama et vLLM vous permet de choisir.
Configurez l’agent pour utiliser le proxy avec les variables d’environnement de l’URL de base.
export ANTHROPIC_BASE_URL=http://127.0.0.1:8080
export OPENAI_BASE_URL=http://127.0.0.1:8080Codex CLI ignore OPENAI_BASE_URL. La commande paritok up écrit donc ~/.codex/config.toml pour vous lorsque codex.enabled: true est défini dans paritok.yaml. Exporter uniquement la variable laisse Codex communiquer directement avec le fournisseur. Vous le verrez au compteur /stats, qui reste à zéro pendant votre travail.
Laissez le listener sur 127.0.0.1, jamais sur 0.0.0.0. Le proxy transmet en amont les identifiants fournis avec chaque requête. Son endpoint /stats non authentifié expose des exemples du contenu original et compressé. Un listener accessible depuis Internet expose donc le contexte privé et les ressources locales de compression. Accédez-y depuis un laptop au moyen d’un tunnel SSH ou d’un VPN, au lieu d’ouvrir le port.
Exécutez-le avec systemd pour qu’il redémarre après un reboot. Adaptez les chemins à votre installation. Créez l’utilisateur paritok utilisé par l’unité et donnez-lui le répertoire d’installation :
sudo useradd --system --home-dir /opt/paritok --shell /usr/sbin/nologin paritok
sudo chown -R paritok:paritok /opt/paritok[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.targetActivez l’unité avec sudo systemctl enable --now paritok, puis exécutez de nouveau curl /health. Une unité qui démarre puis s’arrête immédiatement indique généralement un chemin incorrect vers le fichier de configuration. journalctl -u paritok -n 50 affiche la cause.
L’option hébergée et son coût
Le projet propose également la compression sous forme de service. Définissez use_gpu_server: true avec une clé API obtenue sur paritok.com ; le modèle 4B s’exécute alors sur son infrastructure. Au 2 novembre 2026, le service facture $0.30 par million de tokens de fichiers compressés, prélevés sur un crédit prépayé. Le filtrage des tool schemas est gratuit. Les nouveaux comptes bénéficient de $5 de crédit gratuit, sans carte bancaire. La période de lancement pendant laquelle le service hébergé était gratuit a pris fin le 1 octobre 2026. Le service est donc désormais payant. Cela vous évite d’héberger le modèle de compression, mais vous continuez d’exécuter la gateway.
Cela signifie également que vos prompts et les fichiers lus par votre agent quittent votre machine et sont transmis à un tiers avant d’atteindre votre fournisseur de modèle. L’auto-hébergement existe précisément pour éviter ce détour. Déterminez lequel de ces deux objectifs vous privilégiez avant de définir cette option : sa modification tient sur une ligne, mais ses conséquences sont bien plus importantes.
Comment mesurer vos résultats avant et après
Les chiffres publiés sont ceux du projet, obtenus avec son harness sur SWE-bench Lite. Votre dépôt n’est pas SWE-bench Lite. Faites vos propres mesures.
- Exécutez une semaine normale sans proxy sur le chemin. Relevez séparément les tokens d’entrée, d’écriture du cache, de lecture du cache et de sortie dans la page d’utilisation de votre fournisseur, et non sous la forme d’un total en dollars.
- La semaine suivante, exécutez le même type de travail avec le proxy en frontal.
- Comparez les catégories d’entrée avec leurs tarifs réels et incluez toute variation du coût de sortie. Le proxy ne compresse pas la sortie, mais les changements de comportement de l’agent et du nombre de tours modifient malgré tout la quantité de sortie que vous achetez.
- Comptez les tâches que vous avez dû refaire. C’est la moitié qualitative du compromis, et aucun dashboard ne l’indique.
- Ajoutez les heures GPU de la deuxième semaine avant de comparer les totaux.
Séparer l’entrée de la sortie est important, car leurs tarifs sont très différents et qu’un compresseur n’agit que sur l’une des deux. Au 2 novembre 2026, Claude Sonnet 4.6 coûte $3 par million de tokens d’entrée et $15 par million de tokens de sortie. La lecture du prompt cache coûte 10% du tarif d’entrée, soit $0.30 par million. Le plus récent Claude Sonnet 5.5 coûte $2 et $10, et la lecture de son cache coûte 5% du tarif d’entrée, soit $0.10 par million. L’écart entre le coût des tokens d’entrée et de sortie détermine si un compresseur côté entrée vous apporte un réel bénéfice. Où vont réellement les tokens de Claude Code vous indique quelle partie de votre contexte est suffisamment volumineuse pour justifier une compression.
Le prompt caching complique particulièrement le calcul lié au filtrage des outils. Le bloc d’outils se trouve au début de la requête. Après le premier tour, il est donc normalement servi depuis le cache. Avec Sonnet 4.6, cela coûte 10% du prix d’entrée. Supprimer 21,000 tokens d’un bloc mis en cache économise 21,000 tokens à $0.30 par million, soit environ $0.006 par tour, et non $0.063 comme le laisserait penser le tarif hors cache. Le projet conserve le bloc filtré sans le modifier pendant la session afin que le préfixe mis en cache reste identique. Un filtre qui resélectionnerait les outils à chaque tour invaliderait ce préfixe et pourrait coûter plus cher que les économies réalisées.
Ce qui n’est pas encore vérifié
Tous les chiffres de performance ci-dessus proviennent du projet lui-même. Il existe un test indépendant de compression sur un corpus synthétique, mais il précise explicitement qu’il ne teste pas la réussite des tâches SWE-bench ; les chiffres du projet concernant la qualité de résolution sur SWE-bench Lite restent donc à confirmer indépendamment. Le gateway ayant été open source en juillet 2026, le code dispose également de très peu d’historique opérationnel. Le taux de compression et le chiffre de qualité préservée sont tous deux mesurés par la partie qui a intérêt à ce qu’ils soient bons. Cela ne signifie pas qu’ils sont faux. Ils ne sont simplement pas confirmés, et vous devez les considérer différemment d’un chiffre que vous avez produit vous-même.
Un comportement documenté mérite d’être connu avant d’accuser votre configuration. Le modèle d’embeddings utilisé par le filtre d’outils est chargé lors de la première requête, et non au démarrage. Le projet indique donc une phase de warm-up de 10 à 15 secondes, puis environ 15 ms par appel. Envoyez une requête sans importance après le démarrage du proxy : votre premier vrai tour d’agent ne semblera pas rester bloqué.
Vous pouvez vérifier vous-même quatre points en un après-midi : si le proxy démarre et reste actif, si /stats évolue pendant votre travail, si la ligne de votre fournisseur concernant les input tokens diminue réellement, et si l’agent termine toujours le travail. Pour votre configuration, ces éléments sont bien plus déterminants que n’importe quel benchmark publié.
Concernant son positionnement par rapport à vos autres outils : un gateway LiteLLM auto-hébergé route et comptabilise les requêtes sans modifier leur contenu. Les deux outils répondent donc à des problèmes différents et peuvent être utilisés en chaîne, Paritok étant placé au plus près de l’agent. Si votre objectif réel est de réduire la facture plutôt que d’utiliser cet outil précis, l’ensemble plus large des contrôles de coûts pour un agent sur un VPS comprend plusieurs changements que vous pouvez d’abord essayer gratuitement.
FAQ
Paritok réduit-il ma facture d’API ou seulement l’utilisation du contexte ?
Il réduit la requête avant qu’elle n’atteigne le fournisseur. L’économie dépend du prix des tokens supprimés et du nombre de tours résultant du comportement de l’agent. L’ampleur de cette réduction est inférieure à ce que laisse entendre le chiffre mis en avant. Le chiffre de 74 % correspond au taux de compression du contenu compressé. De bout en bout, le projet indique environ 25 % sur un seul tour et prévoit 63 % au tour 20 en économies de tokens d’entrée. Les tokens de sortie transitent sans modification, mais la quantité générée dépend toujours du comportement de l’agent.
De quelle puissance GPU ai-je besoin pour héberger moi-même le modèle de compression ?
Un GPU est facultatif : Ollama exécute aussi le modèle sur le CPU. Le build q4 fait environ 2.5 GB et le build f16 environ 8 GB. Le modèle tient donc sur une carte de 24 GB, avec une grande marge. Une carte plus petite convient également et modifie le calcul du seuil de rentabilité en votre faveur. Le filtre de schéma d’outils n’a besoin d’aucun GPU : il utilise BAAI/bge-small-en-v1.5, un modèle d’embedding de 130 MB qui s’exécute sur le CPU. Installez paritok[toolselect] sur un VPS standard et vous bénéficiez de la réduction des tool blocks pour le prix d’un peu de RAM.
Que se passe-t-il si le compresseur supprime un élément dont l’agent avait besoin ?
Rien n’est perdu définitivement. Le modèle supprime des segments du contenu transmis, mais les segments compressés portent un tag [REF:id] et le modèle récupère le texte complet avec read_original ou expand_context. Par défaut, le filtre d’outils supprime les outils standard non sélectionnés et les outils MCP non sélectionnés, sauf si son signal de pertinence MCP se déclenche ; dans ce cas, il remplace ces outils MCP par des stubs. La récupération des outils utilise gateway_search_tools et la détection des messages signalant des outils manquants. Le vrai risque est plus discret qu’un fichier manquant : le modèle travaille à partir d’un extrait avec perte et ne se rend jamais compte qu’il devrait demander l’original. Le chiffre de 86.5 % de qualité conservée sur SWE-bench Lite mesure la compréhension en one-shot d’un code source brut compressé, avec la récupération désactivée et la récupération des modifications en production activée ; il ne mesure ni le filtre CPU des schémas d’outils ni la gateway complète sur plusieurs tours.
Pourquoi ma première requête prend-elle quinze secondes ?
Le modèle d’embedding utilisé par le filtre d’outils est chargé lors de la première requête, et non au démarrage. Le projet indique une phase de warm-up de 10 à 15 secondes, puis environ 15 ms par appel. Envoyez une requête factice avec curl après le démarrage du proxy. Le premier tour réel de l’agent ne sera ainsi pas bloqué.
Dois-je utiliser le serveur GPU hébergé plutôt que l’auto-hébergement ?
Cette solution supprime l’hébergement du modèle de compression et les éventuels frais de location d’un GPU, mais vous devez toujours maintenir la gateway. Au 2 novembre 2026, elle coûte $0.30 par million de tokens de fichiers compressés, prélevé sur un crédit prépayé, avec $5 de crédit gratuit pour les nouveaux comptes ; la période de lancement gratuit s’est terminée le 1 octobre 2026. Elle envoie également vos prompts et les fichiers lus par votre agent à un tiers avant de les transmettre à votre fournisseur de modèle. Si vous vous auto-hébergez pour conserver votre code sur une infrastructure que vous contrôlez, ce paramétrage annule la raison pour laquelle vous avez commencé. L’auto-hébergement maintient la compression sur votre propre machine ; les requêtes compressées et les identifiants du fournisseur remontent tout de même vers votre fournisseur de modèle.