OpenClaw trop cher — pourquoi l'agent consomme des tokens et comment économiser

OpenClaw est un agent autonome avec une architecture multicouche. Contrairement aux assistants simples où une invite est envoyée au modèle et une réponse est renvoyée, OpenClaw construit une chaîne de plusieurs rôles et plusieurs itérations. Chaque maillon de la chaîne consomme des jetons, et la consommation totale pour une tâche utilisateur dépasse celle d'un assistant de discussion d'un ordre de grandeur ou plus.

Flux de travail typique d'OpenClaw sur la tâche «écrire le module X» :

1. Le Planificateur lit la description de la tâche et tout le contexte du projet (~30K input + 2K output)
2. Le Décomposeur divise le plan en sous-tâches (~20K input + 1K output)
3. L'Exécuteur pour chaque sous-tâche : lit les fichiers, génère le code, applique les correctifs (5 à 15 itérations × ~50K input + 3K output)
4. Le Critique vérifie les résultats et propose des ajustements (~40K input + 2K output)
5. Le Correcteur applique les corrections (5 à 10 itérations × ~30K input + 2K output)
6. La Vérification finale et la préparation du rapport (~30K input + 1.5K output)

Additionnez tout — pour une tâche moyenne, OpenClaw dépense 800K—1.5M jetons d'entrée et 50—120K jetons de sortie. Pour les tâches complexes avec de longues itérations autonomes, la consommation passe à 5—15M input + 200—500K output.

Chiffres réels pour des types de tâches spécifiques :

• Fonctionnalité simple (une fonction avec test) : ~600K total tokens ≈ 3 $ sur Anthropic
• Fonctionnalité moyenne (nouveau module de 200 lignes) : ~3M total tokens ≈ 12 $
• Fonctionnalité complexe (refactoring + nouvelle fonctionnalité) : ~10M total tokens ≈ 35 $
• Tâche autonome longue (exécution d'une heure avec critique et itérations) : 30—50M total tokens ≈ 100—170 $
• Journée complète d'agent avec plusieurs tâches dans OpenClaw : 100—200M total tokens ≈ 350—700 $

La principale différence avec Cline ou Cursor est qu'OpenClaw effectue 3 à 5 appels de rôle à chaque étape, tandis que Cline n'en fait qu'un. Ce n'est pas un bug — c'est une fonctionnalité qui améliore la qualité de la prise de décision et réduit le nombre d'erreurs. Mais financièrement, elle fait également d'OpenClaw l'outil agentique le plus cher du marché lorsqu'on utilise Anthropic ou OpenAI directement.

Comparaison de la vitesse de consommation avec d'autres outils pour la même tâche :

• Cursor Agent : ~5K—50K tokens par tâche
• Cline : ~500K—5M tokens par tâche
• Claude Code : ~200K—3M tokens par tâche
• OpenClaw : ~3M—50M tokens par tâche (×5—10 de Cline)

OpenClaw prend en charge tous les fournisseurs compatibles OpenAI via les variables d'environnement et un fichier de configuration. Cela signifie que le passage de l'API Anthropic à JoinGonka Gateway ne nécessite aucune modification de code dans OpenClaw lui-même — seulement la modification de l'endpoint et de la clé API.

Comparaison par types de tâches :

L'architecture multicouche d'OpenClaw, qui le rend coûteux chez Anthropic, se transforme en avantage chez JoinGonka : plus d'appels de rôle = plus de précision dans la prise de décision, et cela ne coûte presque plus rien. On peut activer tous les critiques et vérificateurs, laisser les exécutions autonomes pendant la nuit, expérimenter avec de longues chaînes — sans craindre de voir une facture à quatre chiffres le matin.

JoinGonka Gateway facture l'entrée et la sortie de manière égale — à 0.001 $/1M. Chez Anthropic, l'entrée coûte 3 $, la sortie — 15 $. Cela signifie qu'OpenClaw, qui génère de nombreux jetons de sortie intermédiaires lors des échanges de rôles, économise encore plus par rapport à Claude Sonnet 4.5 natif.

Ce qui se trouve sous le capot — le modèle Qwen3-235B-A22B-Instruct (MoE avec 22B de paramètres actifs). Pour les tâches de rôle (planification, exécution, critique), ses capacités de sortie structurée et d'appel d'outil sont significatives : le modèle prend en charge l'appel d'outil natif via PR #767 avec un seuil de 0.958. Sur le benchmark SWE-bench, qui mesure la qualité du développement autonome, Qwen3-235B se maintient au niveau de Claude Sonnet 4.5. Plus de détails — dans l'article sur Qwen3-235B. Contexte général du marché — dans la revue de l'API AI la moins chère en 2026.

OpenClaw lit la configuration à partir des variables d'environnement et d'un fichier de configuration local (par défaut ~/.openclaw/config.yaml). Pour passer à JoinGonka, il suffit de modifier deux valeurs — l'URL de base et la clé API.

Étape 1. Obtenez une clé API JoinGonka. Enregistrez-vous sur gate.joingonka.ai/register, obtenez 10M de jetons gratuits pour les tests, copiez la clé depuis le tableau de bord (format jg-xxx).

Étape 2a. Méthode via les variables d'environnement. La méthode la plus rapide :

export OPENAI_BASE_URL=https://gate.joingonka.ai/v1
export OPENAI_API_KEY=jg-votre-clé
export OPENCLAW_MODEL=Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
openclaw run "tâche"

Pour que les variables soient conservées, ajoutez-les à ~/.bashrc ou ~/.zshrc.

Étape 2b. Méthode via le fichier de configuration. Plus fiable pour la production. Ouvrez ~/.openclaw/config.yaml et ajoutez :

provider: openai
base_url: https://gate.joingonka.ai/v1
api_key: jg-votre-clé
model: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
max_tokens: 2048
temperature: 0.3

Ce fichier de configuration est chargé automatiquement à chaque démarrage d'OpenClaw.

Étape 3. Si vous utilisez plusieurs agents de rôle. OpenClaw permet d'attribuer différents modèles à différents rôles — par exemple, un modèle plus léger pour le planificateur et un modèle plus puissant pour l'exécuteur. Via JoinGonka, vous pouvez utiliser le même Qwen3-235B pour tous les rôles (il est assez puissant pour l'ensemble du pipeline) ou le combiner avec d'autres modèles du réseau, comme Kimi K2.6 (si vous avez besoin d'une longue fenêtre contextuelle pour le critique). Plus de détails — dans l'article sur Kimi K2.6.

Étape 4. Limites et protection. OpenClaw peut limiter le nombre maximal d'itérations et la consommation maximale de jetons par tâche. Même sur JoinGonka, il est judicieux de fixer des limites raisonnables (par exemple, 1M de jetons par tâche) — cela protège contre les boucles accidentelles et accélère le débogage de la logique de l'agent lui-même. Dans la configuration :

limits:
  max_iterations: 50
  max_tokens_per_task: 1000000
  max_cost_per_task_usd: 1.00

Étape 5. Vérification. Lancez une tâche simple — openclaw run "create a hello world function in python". Si l'agent a parcouru le cycle de planification, d'exécution et de vérification et a généré le fichier final — la configuration est terminée. La consommation dans le tableau de bord JoinGonka apparaîtra en temps réel.

La même clé JoinGonka fonctionne avec d'autres outils agentiques : Cline, Cursor, Claude Code. Tous sont facturés à partir du solde général du compte.

Comparons trois profils d'utilisation typiques d'OpenClaw en production.

Profil 1 : «Expérience avec les agents». Un développeur lance OpenClaw 5 à 10 fois par semaine, principalement sur des tâches moyennes pour évaluer la qualité. Consommation mensuelle — ~50M de jetons totaux.

• Anthropic : 50M × 0.005 $ ≈ 250 $/mois
• JoinGonka : 50M × 0.001 $ = 0.05 $/mois. Économie — 5000 fois.

Profil 2 : «Utilisation régulière dans le cadre du flux de travail». OpenClaw est lancé quotidiennement sur des tâches complexes, parfois laissé pour de longues sessions autonomes. Consommation mensuelle — ~500M de jetons totaux.

• Anthropic : 500M × 0.005 $ ≈ 2500 $/mois
• JoinGonka : 500M × 0.001 $ = 0.50 $/mois. Économie — 5000 fois.

Profil 3 : «Pipeline de production sur OpenClaw». Une équipe a automatisé une partie des processus de travail via OpenClaw — génération de rapports, refactoring de l'ancien code, revue de code. Consommation — ~3B de jetons totaux par mois.

• Anthropic : 3B × 0.005 $ = 15000 $/mois
• JoinGonka : 3B × 0.001 $ = 3 $/mois. Économie — 5000 fois.

Au niveau du Profil 3, l'effet est particulièrement intéressant — OpenClaw, de «trop cher pour une automatisation régulière», devient «tellement bon marché qu'on peut automatiser tout ce qui peut l'être». Cela change l'économie même de la prise de décision : une tâche qui semblait auparavant trop coûteuse pour un agent peut maintenant lui être confiée sans hésitation.

Sur un horizon annuel, un utilisateur actif économise environ 30000 $, une équipe — 180000 $. Ce n'est plus seulement une optimisation budgétaire, c'est un changement qualitatif dans la façon dont l'équipe utilise l'IA agentique : gratuitement au lieu de «selon le budget».

En même temps, OpenClaw en tant qu'outil reste inchangé : les mêmes pipelines de rôles, la même décomposition qualitative, le même contrôle par les critiques. Seule la source d'inférence change — et avec elle, l'économie de l'ensemble du flux de travail.

Stratégie de mélange de modèles dans OpenClaw. OpenClaw prend en charge différents modèles pour différents rôles dans le pipeline. Via JoinGonka Gateway, vous pouvez attribuer Qwen3-235B à toutes les étapes (un modèle puissant et universel), ou le combiner avec Kimi K2.6 pour le critique et la vérification finale — Kimi a un long contexte et un raisonnement puissant, ce qui est particulièrement utile pour évaluer les résultats en plusieurs étapes. Étant donné que les deux modèles sont facturés à 0.001 $/1M, il n'y a pas de bonus financier à utiliser un modèle plus «léger» dans les rôles moins chers — mais vous pouvez affiner la qualité des réponses pour chaque étape du pipeline.

Cas de production : automatisation de la revue de code. Un des scénarios réels rendu possible grâce à l'économie de JoinGonka est la revue de code automatique pour chaque pull request via OpenClaw. Pipeline : «lire le diff → analyser chaque fichier → vérifier la couverture des tests → compiler le rapport final». Sur Anthropic, ce pipeline coûterait environ 5 à 15 $ pour une seule PR ; sur JoinGonka — 0.002 à 0.005 $. Une équipe de 10 développeurs, réalisant 50 PR par jour, passe de 750 $/jour sur Anthropic à 0.25 $/jour sur JoinGonka — et l'agent de revue de code passe du luxe au flux de travail quotidien.