Pas un énième wrapper. Un orchestrateur 100 % local dont chaque brique — routage par bandit, CRDT causal, journal cryptographique, auto-évolution — est alignée sur l'état de l'art publié en 2026, et prouvée par un test. Vos données ne quittent jamais votre machine.
Il prouve : 0 fait perdu au sens de l'oracle — six classes de faits rejouées ligne à ligne : chemins de fichiers, numéros de ligne, codes de sortie, messages d'erreur et exceptions, symboles cités, compteurs de résultats. Chaque entrée porte son empreinte sha256, revérifiable en une commande.
Il ne prouve pas : une défaillance racontée en prose pure — sans chemin, sans code d'erreur, sans compteur — est hors du verdict de l'oracle (limite trouvée par notre propre red team, publiée telle quelle). Rien n'est détruit pour autant : l'intégral de chaque sortie reste rappelable par le pointeur sha256 émis en ligne, toujours présent.
Ordre de grandeur honnête : sur les sessions mesurées, −45 à −57 % de tokens d'entrées outillées — quelques centimes par session à ce volume ; l'économie principale vit dans le cache et l'orchestration. (Conditions : Reçus des 15 et 17/08/2026, N=54 entrées chacun, rejeu local 0 $, oracle 6 classes.)
Les chiffres sont des mesures de tests reproductibles ou des estimations tracées run par run (grille tarifaire Anthropic en vigueur) — jamais un slide. Détail technique complet : ce qu'on a construit récemment.
ChaserBench v2 : 30 tâches appariées (cascade Chaser vs Sonnet direct), corpus gelé par SHA-256, et le code produit est exécuté en sandbox contre des tests jamais montrés au système noté. Delta qualité 0,0 exactement (29/30 des deux côtés), borne basse empirical-Bernstein 0,14 > 0.
rejouez le banc : /benchCompression, AI-Scientist-v2, taux d'acceptation, réduction de contexte — chacune avec son protocole, son échantillon et sa donnée brute. Un seul chiffre de tête ici ; le reste est rangé et vérifiable, pas caché.
voir /mesures« Au sens fort » = un tiers peut refaire le calcul sans nous croire : corpus gelés, journal scellé (RFC 6962), vérificateur hors-ligne en Python standard — la vérification a été rejouée de l'extérieur (« valide : true »). Le mode d'emploi complet.
Chaque brique est adaptée d'un travail publié, implémentée en bibliothèque standard, et prouvée par un test déterministe. Ce sont des mécanismes mesurés et testés — pas des slides.
N outils → 2 méta-outils : le modèle écrit du code (Programmatic Tool Calling), exécuteur AST sûr. Chiffre attesté sur vos propres schémas et scellé (Merkle).
jusqu'à −98,8 % · attestéJournal inviolable hash-chaîné + racine Merkle (RFC 6962). Vérifiable à l'octet — pas « nos compteurs ».
RFC 6962 · falsification détectéeCRDT causal Fugue au caractère + horloges hybrides : deux sessions Claude Code ne s'écrasent plus.
16/16 tests · 0 perteOrcaLocal : embeddings + bandit contextuel (LinTS) + cascade auto-vérifiée (FrugalGPT), escalade par l'incertitude. Gain net prouvé sur trafic réel : 195 décisions, 89 % d'acceptation, borne basse > 0 (anytime-valid).
prouvé sur 195 décisions réellesSuivi de flux d'information (primitive CaMeL, DeepMind), anti-injection, anti-exfiltration, scan MCP.
6 modules · policy-as-codeSéquences de confiance anytime-valid (méthode Netflix/Statsig) + réduction de variance CUPED, export OpenTelemetry.
réduction 56,9 % (borne 43,6 %)Chaser améliore ses propres prompts en réfléchissant sur ses échecs, frontière de Pareto (ICLR 2026 Oral).
35× moins d'essais que le RL13 piliers alignés sur l'état de l'art publié, chacun en bibliothèque standard, zéro dépendance. Veille SOTA du 16/07/2026 : 9 raffinements de plus (juge VERDI, dual-LLM CaMeL, cache couche 0…).
143/143 modules branchés et testésCe sont des mécanismes mesurés et des tests, pas des résultats clients — Chaser est jeune et l'annonce honnêtement. Le « jusqu'à −98,8 % » est le plafond sur des schémas très verbeux ; sur un petit jeu d'outils courts c'est plutôt −55 à −65 %. Dans les deux cas le chiffre est attesté sur vos propres outils et scellé — pas un slide.
tokens de contexte économisés — mesurés, pas estimés
Chiffre lu directement dans l'instrumentation de Chaser sur son propre usage :
852 567 caractères compressés (compresseur + saillance), convertis à la
calibration réelle de 2,215 caractères/token — mesurée via l'endpoint officiel
count_tokens. Et ce ne sont que 2 des leviers de Chaser.
Preuve d'usage réel : l'auteur fait tourner Chaser au quotidien — ~1,5 million de tokens traités le mois dernier, à très faible coût grâce au routage vers les modèles les moins chers et au caching. Ce n'est pas une démo, c'est un outil utilisé intensivement.
Téléchargez Chaser Check, notre installeur gratuit. Il fait deux choses, et rien de plus :
Python, Node.js, Git et Claude Code sont détectés et installés automatiquement s'ils manquent (winget, puis téléchargement officiel en repli). Votre machine est prête à recevoir Chaser.
Un diagnostic local confirme que tout est en place et vous montre ce que Chaser allégerait — par exemple le nombre de serveurs MCP qui gonflent votre prompt système à chaque tour. Aucune donnée ne quitte votre machine.
Compatible Windows 10 et 11 · macOS est en bêta ouverte.
Vérifiez l'intégrité avant d'exécuter — le fichier téléchargé doit avoir exactement cette empreinte SHA-256 :
1d1f84d0193737a05bbe2cded0a542a52e677c13b74036ccd863b460558841e4
Sous Windows, ouvrez PowerShell et collez :
Get-FileHash "$HOME\Downloads\Chaser-Check.exe" -Algorithm SHA256
— l'empreinte affichée doit être identique.
Vous pouvez aussi la coller sur
VirusTotal
pour voir l'analyse antivirus publique.
Une fois installé, le paquet contient son guide d'installation, LISEZMOI_TESTEUR.md, à la racine — c'est la première chose à ouvrir.
Nos binaires ne sont pas signés Authenticode.
Ni Chaser Check, ni l'installeur complet livré après achat : les deux ressortent
NotSigned si vous le vérifiez vous-même avec
Get-AuthenticodeSignature. Le certificat de signature de code n'est pas
encore acquis — nous ne l'annonçons donc pas comme « en cours », ce que cette page
a dit à tort jusqu'au 01/08/2026.
Conséquence concrète : SmartScreen affichera « Éditeur inconnu » à l'exécution. Pour passer outre : Informations complémentaires → Exécuter quand même. Ce que vous pouvez vérifier en attendant, et qui vaut mieux qu'une promesse : l'empreinte SHA-256 ci-dessus, celle de l'installeur complet publiée dans version.json (elle décrit le fichier réellement servi, contrôlé à chaque publication), et l'analyse VirusTotal publique.
Dès que le certificat sera en main, la version suivante sera signée et cette section le dira — avec la date, pas au futur.
Chaser Check n'embarque aucun composant du produit : il installe seulement les prérequis publics et lit votre configuration en local. Le cœur de Chaser (compression, Bouclier de sécurité, mesure réelle des tokens, garde-budget) s'installe et s'active uniquement après achat, via votre clé de licence nominative.
Chaser Lite est un plugin gratuit pour Claude Code (et 20+ agents : Cursor, Copilot…). Deux compétences, zéro dépendance, 100 % local :
Compte les schémas d'outils MCP + plugins re-envoyés dans votre prompt système à chaque tour, et estime les tokens récupérables. Lecture seule, aucun chiffre inventé.
Dégonfle le prompt
système en une écriture réversible de settings.json (chargement différé des outils +
règles de refus). Sauvegarde automatique, annulable en une commande.
# Via le CLI skills (Claude Code, Cursor, et 20+ agents) npx skills add HQU-kenaxvi/chaser-lite # Ou comme plugin Claude Code /plugin marketplace add HQU-kenaxvi/chaser-lite /plugin install chaser-lite@chaser
Chaser Lite mesure et allège le coût de contexte, gratuitement. La version complète — moteur qui route le travail vers des modèles moins chers, garde-budget, chat éco, mémoire persistante, Cockpit et Bouclier de sécurité — c'est Chaser Pro.
Vous ouvrez une nouvelle session Claude Code et vous perdez 10 minutes à réexpliquer l'architecture du projet, les conventions de code et les décisions prises la veille.
Votre facture API Anthropic grimpe mois après mois parce qu'Opus traite systématiquement des tâches qu'un modèle moins cher aurait suffi à résoudre.
Une session plante en plein milieu d'une tâche longue, et tout le contexte accumulé — décisions, erreurs déjà corrigées, état d'avancement — disparaît avec elle.
Tout contenu externe (page web, log, fichier, ticket) qui transite par Chaser est sanitisé avant d'être injecté dans un prompt, pour neutraliser les tentatives d'injection. Aucune donnée ne quitte votre machine, à l'exception des appels légitimes vers l'API Anthropic. Vous gardez un contrôle total et visible sur ce qui est stocké.
Le handoff entre sessions Claude Code est automatisé de bout en bout, avec une mémoire long terme stockée localement en JSONL. Les informations périmées sont invalidées automatiquement selon leur ancienneté. En cas de crash, le contexte est repris exactement là où il s'est arrêté, sans perte.
Sur la clé API, Chaser route chaque tâche vers le modèle le moins cher capable de la traiter, avec escalade uniquement si nécessaire. Combiné au Batch API et au prompt caching (tokens relus au dixième du tarif), la facture API baisse — et le compteur intégré affiche VOTRE ratio mesuré, borne basse. Sur Claude Code, le recyclage de sessions et le compresseur de sorties évitent de refaire un travail déjà fait — le trafic de votre abonnement n'est jamais modifié.
Les recettes déterministes évitent tout appel de planification au modèle pour les tâches répétitives, pour un coût estimé ~0,01 $ par run. Le cockpit local affiche en continu l'état de santé du système et l'évolution des économies estimées, pour ajuster votre usage en connaissance de cause.
Et si Anthropic change ses prix ou ses modèles ? Chaser n'est pas enchaîné à un fournisseur : sa passerelle compatible OpenAI accepte n'importe quel harnais (Codex, agents maison…), la cascade sait router vers plusieurs fournisseurs, et le Tier-0 local (Ollama) traite le trivial à 0 € sur votre machine. L'orchestration frugale survit aux grilles tarifaires.
Vous changez de session Claude Code sans jamais avoir à réexpliquer votre projet.
Le contexte (décisions, état d'avancement, erreurs déjà traitées) est transféré automatiquement entre sessions, sans action manuelle de votre part.
Vous savez exactement ce que le système a mémorisé, et vous pouvez l'effacer à tout moment.
La mémoire long terme est stockée localement en JSONL, consultable en clair, avec invalidation temporelle automatique des informations périmées.
Vous ne payez plus le prix d'Opus pour des tâches qu'Haiku sait résoudre.
Un modèle bon marché tente d'abord la tâche avec auto-évaluation de sa réponse ; l'escalade vers Sonnet puis Opus ne se déclenche que si nécessaire.
Les tâches répétitives s'exécutent sans repasser par une phase de planification coûteuse.
Des plans YAML pré-validés remplacent l'appel de planification au modèle, pour un coût estimé ~0,01 $ par run.
Moins de tours redondants : le travail déjà fait n'est pas refait. Le trafic de votre abonnement n'est jamais modifié.
Les sorties verbeuses sont compressées avant d'être réinjectées dans le contexte, réduisant le volume de tokens consommés sur les tours suivants.
Vous voyez en un coup d'œil combien vous économisez et si le système est en bonne santé.
Dashboard local affichant les économies estimées, l'état de santé du système et le contenu de la mémoire stockée — visible et effaçable.
Chaque session démarre sur un résumé par thèmes, pas sur un déballage de 200 faits.
La mémoire est regroupée en scènes thématiques, coiffées d'un profil distillé lu en premier ; le détail d'une scène ne se charge que si la tâche en a besoin. Moins de tokens à chaque démarrage, calcul local, zéro appel API.
Le contexte volumineux peut être lu en images 2 à 3× moins chères — et cette fidélité se mesure, elle ne se promet pas.
Un test intégré vérifie, modèle par modèle, la restitution byte-exacte du contenu imagé ; les valeurs critiques (hashs, clés, identifiants) restent toujours en texte à côté des images. Mesuré : fiable sur Sonnet, garde-fous actifs pour Haiku.
Chaser agit sur deux surfaces de facturation distinctes, avec deux leviers opposés : sur l'une il évite le travail redondant, sur l'autre il choisit mieux quel modèle facturer.
Le travail déjà fait n'est pas refait : contexte redondant non réinjecté, sorties verbeuses compressées. Le trafic de votre abonnement n'est jamais modifié.
Facturée à l'usage : le routage Haiku/Sonnet/Opus, la cascade auto-évaluée, le Batch API et le prompt caching (tokens relus au dixième du tarif) réduisent la facture ; le compteur intégré affiche votre ratio mesuré, borne basse.
Exemple réel tracé : un run de 5 posts LinkedIn a coûté 0,0117 $ au lieu de 0,0584 $ si tout avait tourné sur Opus, soit -80 % — la trace JSON du run fait foi.
Chaser s'installe comme un ensemble de hooks Claude Code et de modules Python en bibliothèque standard. Rien ne tourne en tâche de fond : chaque pièce est déclenchée par votre usage, et tout est inspectable en clair sur votre disque.
Haiku tente la tâche, puis note sa propre réponse contre des critères objectifs (format attendu, contraintes respectées, faits chiffrés présents). Sous le seuil, la tâche remonte à Sonnet, puis Opus en dernier recours — et la trace JSON enregistre qui a fait quoi, pour quel coût.
Chaque module est conçu pour s'effacer plutôt que bloquer : si une compression échoue, le contenu passe en clair ; si Ollama est absent, le repli est automatique ; si un hook plante, Claude Code continue comme si Chaser n'existait pas. Un rollback complet est fourni.
Toute compression est soumise à un garde-fou déterministe : nombres, chemins, versions, codes et URLs doivent survivre à l'identique, sinon la compression est rejetée et le texte d'origine est conservé. Les archives sont réversibles byte à byte (17/17 tests).
# recette déterministe (YAML) nom: serie_posts_linkedin modele: claude-haiku-4-5 etapes: - generer: 5 posts, ton direct - verifier: longueur, hashtags budget_max_usd: 0.05
Une recette remplace la phase de planification : ~0,01 $ le run.
# mémoire long terme (JSONL) {"type": "piege", "texte": "port 443 tenu par tailscale, lier l'IP publique", "confiance": 90, "rappels": 12}
Chaque fait est lisible, noté, daté — et effaçable d'une commande.
# trace d'un run (JSON) {"taches": 5, "modele": "haiku → sonnet(1)", "cout_usd": 0.0117, "cout_si_opus": 0.0584, "economie": "-80 %"}
Les économies annoncées sortent de ces traces, pas d'un slide.
Les économies dépendent de votre usage. La dédup ne gagne que sur du contenu répété ; le routage ne gagne que si vos tâches n'exigent pas toutes Opus. Les pourcentages affichés sont des estimations tracées, pas une promesse contractuelle.
La lecture optique dépend du modèle. Mesuré chez nous : restitution exacte 15/15 sur Sonnet, mais 0/15 sur Haiku en densité maximale — c'est pourquoi les valeurs critiques restent toujours en texte, et le test de fidélité est livré avec l'outil.
L'historique de conversation en cours est hors de portée des hooks Claude Code : Chaser agit sur les sorties d'outils, le contexte réinjecté et les appels API, pas sur ce que l'interface a déjà affiché.
Le tier local (Ollama) est optionnel et jamais requis : sans lui, tout fonctionne — vous perdez seulement le routage à 0 $ des messages triviaux. Chaser ne l'installe pas à votre place.
La plupart des outils autour de Claude sont une couche de prompt et un peu de routage. Chaser embarque des briques qui sont, littéralement, à la frontière de la recherche informatique 2026 — chacune adaptée, implémentée en bibliothèque standard, et prouvée par un test déterministe. Voici ce que le reste du site ne montrait pas.
Au lieu d'injecter des dizaines de milliers de tokens de schémas d'outils à chaque tour,
Chaser expose 2 méta-outils et fait écrire du code (façon Programmatic Tool Calling
d'Anthropic / Code Mode de Cloudflare), avec un exécuteur restreint et sûr. La réduction est
attestée sur vos propres schémas (outil MCP attester) et scellée dans le journal Merkle.
Vos économies ne sont plus « nos compteurs, notre chiffre » : chaque mesure est scellée dans un journal inviolable hash-chaîné + racine Merkle avec preuves d'inclusion et de cohérence RFC 6962 et des checkpoints signés chaînés (STH) — le mécanisme exact de Certificate Transparency. Réécriture ET retour arrière du journal sont détectés ; vous vérifiez une entrée sans tout le journal.
✓ RFC 6962 : inclusion + cohérence + STH · rollback détectéDeux sessions Claude Code sur le même dépôt ne s'écrasent plus : versioning causal (horloges logiques hybrides), CRDT de texte Fugue au caractère, notifications de conflit et fusion sémantique. Convergence prouvée par test de propriété (300 ops, 5 sessions, 12 ordres de livraison → rendu identique) + compaction causale qui purge sans jamais changer le rendu.
✓ convergence prouvée · compaction auto-vérifiée · zéro pertePas une simple heuristique : routage prédictif par embeddings, bandit contextuel (Thompson/LinTS avec oubli D-LinUCB), cascade auto-vérifiée (FrugalGPT) et escalade jaugée par l'incertitude réelle du modèle local. Seuil d'acceptation à risque contrôlé (Clopper-Pearson) : garantit statistiquement le taux de mauvaises réponses acceptées — il n'appelle le cloud que quand il doute.
✓ garantie de risque distribution-free · seuil calibréAu-delà du blocage de rm -rf : suivi de teinte / contrôle de flux
d'information (primitive CaMeL de Google DeepMind) branché sur tous les puits sensibles —
web (exfiltration par query-string), écritures de config (.bashrc, clés SSH), shell —
avec détection d'obfuscation base64. Bloque l'injection indirecte, pas seulement la syntaxe.
Les économies sont estimées avec des séquences de confiance anytime-valid (la méthode de Netflix/Statsig, valide même en observation continue) + réduction de variance CUPED, et exportables en OpenTelemetry. Pas un slide : une borne de confiance.
✓ réduction prouvée 56,9 % (borne basse 43,6 %)Chaser améliore ses propres prompts en réfléchissant en langage naturel sur ses échecs (via un modèle local, 0 $), garde une frontière de Pareto et fusionne les lignées complémentaires (GEPA+merge, ICLR 2026 Oral). Gain réel mesuré et scellé : +12,5 pts d'exactitude sur un modèle local. Jamais de régression : la meilleure des deux méthodes est retenue.
✓ +12,5 pts mesurés · réflexion locale 0 $ · ROI scelléLe build livré porte une attestation de provenance (in-toto / SLSA), un SBOM, une empreinte reproductible et un log de transparence — plus une révocation vérifiable hors-ligne. La sécurité supply-chain d'un logiciel sérieux, pas d'un script vendu par email.
✓ provenance signée · build reproductibleLes gains ne sont pas qu'un slide : un banc public gelé (corpus lié par SHA-256) compare deux bras appariés avec des bornes anytime-valid. Run réel sur API : −58 % de coût à tâche égale, gain prouvé (borne basse > 0), qualité préservée — chaque résultat scellé au journal et publié.
✓ −58 % mesuré · banc public/benchChaque décision de routage, de cache ou d'escalade s'explique en clair. Les modèles de
routage étant linéaires, la contribution de chaque objectif (coût, qualité, latence, risque) est
exacte, pas une approximation. Commande /pourquoi, moins de 0,4 ms par décision.
Coût, qualité, latence et risque optimisés ensemble (scalarisation de Tchebycheff, 3 presets). Le passage en production est verrouillé par un estimateur doubly-robust : la bascule n'a lieu que si le gain est prouvé (borne anytime-valid > 0), jamais sur du bruit.
✓ OPE doubly-robust · risque réel dans la décisionChaque session émet un rapport SARIF 2.1.0 (le standard lu par GitHub Code Scanning) depuis les décisions du Bouclier, plus une détection statistique de canaux cachés. Mode Zero-Trust opt-in : tout effet de bord hors liste blanche demande confirmation.
✓ SARIF standard · Zero-Trust · canaux cachés (CUSUM)| Capacité | Sans Chaser | Avec Chaser |
|---|---|---|
| Schémas d'outils envoyés (schémas verbeux) | ~15 000 tokens | ~180 tokens (jusqu'à −98,8 %, attesté) |
| Preuve des économies | « nos compteurs » | journal crypto vérifiable |
| Réduction de contexte (exemple mesuré) | 66 000 tokens | 12 000 tokens (−82 %) |
| 2 sessions sur le même dépôt | écrasement | fusion CRDT sans perte (~10 200 propriétés vérifiées) |
| Amélioration du système | manuelle | auto-évolution GEPA |
| Gain de coût | « nos compteurs » | −58 % prouvé (banc public, borne > 0) |
| Décisions de routage | boîte noire | expliquées en clair (/pourquoi) |
143 modules branchés et testés (santé complète). Chaque livraison repasse la porte complète — pas une validation datée une fois pour toutes : zéro régression, coût 0 $. Ces couches sont opt-in et prouvées hors-ligne ; cascade, cache et juge sémantique sont en plus éprouvés sur trafic réel. Le trafic de votre abonnement OAuth n'est jamais modifié.
Anthropic compte plus de 1 000 clients à 1 M$+/an (presse spécialisée, 2026) — soit ~19 200 $ d'API par semaine chacun. En extrapolant notre −58 % de coût à tâche égale (banc apparié, borne basse statistique > 0, qualité préservée) selon la part du trafic qui passe par Chaser :
30 % du trafic adressable (workloads verrouillés, prompt caching déjà en place) : ~3 300 $/semaine.
~170 k$ / an60 % du trafic adressable : ~6 700 $/semaine — le client paie ~12 500 $ au lieu de 19 200 $.
~350 k$ / an100 % du trafic se comporte comme notre banc : ~11 100 $/semaine — c'est le plafond théorique, pas la promesse.
~580 k$ / anCeci est une extrapolation, pas une mesure : le −58 % est prouvé sur notre banc public (30 tâches appariées, corpus gelé), pas encore sur le trafic d'un client de cette taille. La seule preuve qui vaille chez vous : un pilote mesuré sur votre propre trafic — Chaser journalise chaque run et scelle les mesures (Merkle), vous vérifiez vous-mêmes. Face à une licence Équipe à 490 €, même le scénario prudent paie le déploiement plusieurs centaines de fois.
14 jours, sur votre trafic réel, sans nous envoyer une seule donnée. Jour 0 : Chaser scelle la baseline de votre consommation dans un journal Merkle local — elle devient impossible à réécrire après coup, y compris par nous. Pendant 14 jours, chaque orchestration est mesurée face à sa référence « même travail sans routage ». Jour 14 : un rapport d'une page, signé Ed25519, avec la médiane par orchestration (jamais l'agrégat seul) et la projection annuelle pour votre effectif. Vous vérifiez la signature et l'intégrité du journal vous-mêmes, hors ligne, avec le vérificateur autonome — sans nous faire confiance.
Sur le pilote mesuré de 14 jours (baseline scellée au jour 0, journal Merkle, rapport final signé Ed25519 que vous vérifiez vous-mêmes hors ligne) : si la médiane des économies mesurées par orchestration sur votre clé API est inférieure à 45 % de la référence sans routage, la licence est intégralement remboursée. Aucun autre outil ne peut prendre cet engagement, parce qu'aucun autre ne vous laisse auditer la mesure : ici elle est scellée chez vous, vérifiable par vous (/preuves/).
Périmètre : les orchestrations routées par Chaser
pendant le pilote et disposant d'une référence comparable dans leurs traces
(le payé et la référence portent sur les mêmes runs) ; l'indicateur est la
médiane par orchestration, jamais l'agrégat seul.
La règle, sans avoir à nous croire : une orchestration est éligible si sa trace
porte à la fois le coût payé et le coût de référence — aucun seuil, aucun réglage, aucune
appréciation. Une économie nulle ou négative reste comptée : écarter les cas
défavorables remonterait la médiane. Le rapport publie le nombre d'orchestrations totales,
éligibles et exclues avec le motif de chaque exclusion, et ces nombres sont scellés au
journal Merkle comme le reste. Détail contractuel dans les
CGV §6 bis.
Chaser est un produit local que vous installez une fois : aucun coût récurrent, aucune dépendance à un service tiers.
Non. Chaser est une bibliothèque Python standard, sans serveur à configurer ni dépendance externe à installer. Comptez quelques minutes pour l'intégrer à votre usage de Claude Code ou de l'API.
Elles restent sur votre machine. Chaser ne fait transiter aucune donnée vers un serveur tiers ; les seuls appels réseau sont ceux que vous faites déjà vers l'API Anthropic. La mémoire stockée localement en JSONL est consultable et effaçable à tout moment depuis le cockpit.
Ce sont de bons outils, mais pour un autre usage. LiteLLM route des appels API, il ne gère ni handoff entre sessions Claude Code ni mémoire long terme. LangChain est un framework généraliste à intégrer et maintenir ; Chaser est une brique locale et ciblée, pensée spécifiquement pour l'usage quotidien de Claude, pas pour construire une application autour.
Les pourcentages d'économie estimés dans cette page sont calculés sur la grille tarifaire actuelle d'Anthropic. Si les prix changent, les montants absolus bougent, mais la logique de routage, de cascade et de caching reste pertinente tant qu'il existe un écart de prix entre modèles.
Ces outils font une chose, souvent bien : compresser ce qui passe par un proxy API. Chaser couvre ce terrain (compression, dédup, optique avec fidélité mesurée) et y ajoute ce qu'un proxy ne voit pas : le handoff entre sessions, la mémoire long terme, le Bouclier de sécurité, les recettes et le Cockpit. Nous publions un banc comparatif honnête dans la documentation du produit, réserves incluses.
Chaser est développé en France par un développeur indépendant, pour résoudre ses propres factures API et ses propres limites d'abonnement Claude Code. Chaque module est utilisé quotidiennement sur la machine de son auteur avant d'entrer dans le produit — et vous écrivez directement à la personne qui l'a construit, pas à un support de niveau 1.
181 suites de tests hors-ligne accompagnent le code, les archives sont réversibles byte à byte, la latence des hooks est mesurée (~89 ms/tour) et les économies sortent de traces JSON consultables. Le produit est actuellement en bêta avec des utilisateurs réels ; les retours publics arriveront quand ils existeront — pas avant. Les évolutions sont publiées sur la page Nouveautés.
Si Chaser ne réduit pas votre facture ou ne simplifie pas votre usage de Claude Code, vous écrivez un email et vous êtes remboursé intégralement, sans justification à fournir.
Chaser est fondé par Ken Caroly, épaulé par trois contributeurs au développement et au financement de la recherche — C.kenaxvi, T.Alrum et N.Wisk (crédités sous pseudonyme) — et construit en orchestrant Claude et une vingtaine d'agents IA spécialisés. Autrement dit : ce produit est construit exactement avec la méthode qu'il vend — chaque module, chaque test et cette page elle-même sont sortis de cette orchestration.
Pourquoi le dire ? Parce que c'est la meilleure preuve qui existe : si un seul humain bien outillé peut construire et prouver tout ce qui précède, c'est que l'orchestration d'agents fonctionne. C'est précisément ce que Chaser met entre vos mains.
Installation en quelques minutes. Local, privé, mesurable.
Commander Chaser maintenantPaiement en ligne sécurisé (Gumroad, CB ou PayPal) — clé de licence livrée automatiquement par e-mail, récupérable aussi sur chaser-orchestrator.com/cle. Commande par e-mail toujours possible : contact@chaser-orchestrator.com.
Le tarif de lancement est valable jusqu'à la fin du mois en cours, ensuite le prix repasse au tarif standard.