Pourquoi et comment j'ai basculé de Claude à Kimi : retour d'expérience d'un setup hybride

Voici ma situation, avec mes vraies factures : trois mois, deux fournisseurs, et une bascule. La question n'a jamais été « est-ce que Kimi est meilleur que Claude », mais : est-ce raisonnable de tout miser sur un seul fournisseur — et de financer des plafonds qui coupent le travail en plein milieu ?

Le vrai argument n'est pas le prix — même si 385,96 € sur deux mois chez Anthropic contre un abonnement unique à 204 €, ça compte. Le vrai argument, ce sont les ruptures de travail récurrentes : les plafonds Claude coupaient mes runs en plein milieu, et chaque recharge API achetait la fin du mois, pas la fin du run. Ce que j'ai fait : résilier l'abonnement Claude, monter Kimi en Ultra, et bâtir une stack hybride qui ne dépend plus d'aucun fournisseur unique. La direction est assumée : un seul abonnement lisible + le local — et faire évoluer l'agentique local vers Kimi dès que c'est techniquement possible, pour la cohérence de l'essaim : même langage, même mécanique partout. Voici le bilan honnête, y compris ce que j'ai perdu.

1. Pourquoi : les raisons, dans l'ordre où elles comptent vraiment

1.1 Philosophie hybride et souveraineté

C'est ma vraie raison n°1, donc je la dis d'abord. Anthropic vend un accès ; Kimi vend une sortie de secours. Kimi K3.1 Pro est le seul frontier model du marché à annoncer la publication de ses poids ouverts (attendus autour du 4 novembre 2026), à exposer un endpoint compatible avec l'API Anthropic (§1.3) et à afficher un prix lisible. Concrètement : une PME ne pourra jamais héberger Claude chez elle — c'est structurel, pas une question de budget. Avec Kimi, la porte reste ouverte : le jour où les poids sortent, le self-host devient possible, et en attendant c'est le local (§2) qui prend le relais dès qu'une tâche n'a pas besoin du frontier. Pour quelqu'un dont le positionnement est « swarm d'agents souverain, chez soi », un fournisseur qui laisse une porte de sortie compte plus qu'un benchmark de plus.

1.2 Le prix — sans exagérer

K3.1 Pro n'est pas moins cher que Sonnet : c'est le même tarif. Ce qui est vrai : des performances annoncées niveau Opus au prix de Sonnet, avec 1M de jetons de contexte natif dans l'API. Et côté abonnement, mes factures du tableau d'ouverture parlent d'elles-mêmes. Les tarifs officiels sont publiés sur la page pricing de la plateforme Moonshot ; mes chiffres ci-dessus sont mes constats du jour, pas une source.

1.3 Compatibilité : l'endpoint Anthropic

Kimi expose un endpoint compatible avec l'API Anthropic : https://api.kimi.com/coding/ pour l'abonnement Kimi Code (la clé se crée dans la Kimi Code Console), et https://api.moonshot.ai/anthropic pour la plateforme pay-as-you-go, au token. Conséquence concrète : mes outils existants (Claude Code en tête) basculent sans changer de chaîne. La migration coûte une heure, pas un mois.

1.4 Le choix du cœur, et le graal que je ne peux pas tester

Transparence complète : mon choix de cœur, c'était Qwen. DeepSeek, je n'en suis pas utilisateur. Kimi s'est imposé parce qu'il avait déjà fait ses preuves chez moi avec K2.7 Coder — et parce qu'aucun autre frontier n'ouvre la même porte. Reste l'impossibilité, assumée : le vrai graal serait l'agentique hybride tout-Kimi — les poids de K3.1 en local, le cloud en appoint. Pas chez moi : les poids demandent de l'ordre de 1,4 To de mémoire GPU agrégée, mon rig en a 32 Go. La porte de sortie existe ; elle est simplement trop lourde pour moi aujourd'hui. Chaque situation est un enfer de compromis — la seule question est de choisir ceux qu'on peut vivre.

2. La stack hybride : un seul abonnement, le reste en mesuré

Règle d'or : un seul abonnement (Kimi). Tout le reste est pay-per-token ou local. Si un jour Kimi ne suffit pas sur une tâche, je paierai cette tâche au token ailleurs — pas un deuxième abonnement. C'est précisément le schéma « promesse → plafond → déception » que je fuis.

Matrice de routing

⚠️ Pièges OpenRouter : rate limits serrés sur les modèles gratuits, modèles qui changent sans préavis, et vos données qui transitent chez un 3ᵉ intermédiaire. Jamais pour du code client ou du sensible.

Le hardware qui fait tourner le local

Mon rig : Ryzen 7 7800X3D, 64 Go DDR5, RTX 5080 16 Go (PCIe x16) + RTX 4070 Ti SUPER 16 Go en eGPU (lien x4, soit ~32 Go de VRAM au total).

Règle n°1 du multi-GPU hétérogène : un modèle = un GPU. Le lien x4 de l'eGPU sature si on fait du tensor-split entre les deux cartes ; on assigne donc chaque modèle entier à une carte, sans trafic inter-GPU. Je ne me contente pas de la respecter à la main : turnstile, mon allocateur GPU déterministe, l'impose — une file d'attente propre, et des vérifications en direct que le modèle qui répond est bien celui alloué. Dans une architecture où c'est un router logiciel qui choisit le backend, cette dernière garantie n'est pas un détail.

Ces mesures sont prises en conditions de production réelle — le CPU sert deux autres modèles pendant les mesures — pas dans un labo vide. C'est volontaire : un chiffre de labo ne vous dit rien de ce que vous obtiendrez chez vous.

Attention au KV cache : un contexte long en local mange la VRAM rapidement. C'est un feature de l'architecture : tout ce qui dépasse ~16–32k de contexte est routé vers Kimi (1M natif) — pas vers un quant plus agressif.

Note alimentation : 5080 (~360 W) + 4070 Ti SUPER (~285 W) + 7800X3D → prévoir une alim de 1000 W (l'eGPU a son propre bloc).

Config minimale viable pour vous : un simple GPU 16 Go suffit pour un 9B en quant élevé ou un 27B en IQ3 ; 8 Go → 7–8B. Tout ce qui manque localement est routé vers l'API.

Le laptop, plan de contrôle : « cerveau léger, muscles lourds »

Troisième élément de l'architecture : un laptop Ryzen 7, 64 Go RAM, qui pilote tout — et c'est peut-être la partie la plus utile, parce qu'elle inverse la logique habituelle « tout allumé tout le temps ». Un rig avec 5080 + 4070 Ti SUPER consomme ~100–150 W au repos (soit ~10–15 €/mois à ne rien faire, plus bruit et usure) ; un laptop tire 15–35 W. Le laptop reste donc allumé en permanence, le rig ne s'allume que pour le calcul.

Principe : le laptop reçoit les requêtes, applique la matrice de routing §2, et appelle le bon backend — lui-même (tâches légères), le rig (réveillé par Wake-on-LAN si besoin), ou les API distantes. Concrètement : n8n sur le laptop → HTTP node → http://rig:8080/v1/chat/completions.

Pièges documentés :

• Le streaming de tokens déteste le WiFi (gigue) — câblez ce qui peut l'être ; à distance, Tailscale/WireGuard, jamais d'exposition directe des ports llama.cpp sur Internet.
• Wake-on-LAN à configurer dans le BIOS + carte réseau du rig, sinon « piloter » devient « se lever pour appuyer sur le bouton ».
• Point unique de défaillance : il y en avait un — le laptop. La réponse s'appelle mindhub : un petit nœud basse consommation, allumé en permanence, qui tient le plan de contrôle minimal de l'essaim (la règle : ce qui se pilote depuis le laptop doit aussi se piloter depuis mindhub). Le laptop peut tomber, le rig peut dormir : l'essaim reste joignable et commandable depuis la poche, sans réveiller la puissance. L'export n8n quotidien reste en place — restaurer un nœud doit tenir en minutes.

3. Comment : la migration concrète

3.1 Basculer Claude Code sur Kimi

La procédure officielle est celle de la documentation Kimi Code pour les agents tiers. Trois étapes, dans l'ordre.

Étape 1 — la clé. Dans la Kimi Code Console (l'abonnement, pas la plateforme au token) : « Create API Key », nommez-la, copiez-la — elle n'est plus lisible après fermeture de la boîte de dialogue. La clé de la plateforme pay-as-you-go (platform.moonshot.ai, endpoint https://api.moonshot.ai/anthropic) reste une option de repli au token, hors abonnement.

Étape 2 — le script officiel, avant le premier lancement. Après l'installation de Claude Code, ne le démarrez pas tout de suite : ce script active le support des modèles tiers dans ~/.claude.json (penguinModeOrgEnabled + hasCompletedOnboarding) et supprime les anciennes variables de modèle d'un éventuel bloc env dans ~/.claude/settings.json — une vieille configuration y écraserait la nouvelle :

node --eval "
const fs = require('fs');
const os = require('os');
const path = require('path');

// enable third party model support and fast mode
const claudeJsonFilePath = path.join(os.homedir(), '.claude.json');
if (fs.existsSync(claudeJsonFilePath)) {
    const content = JSON.parse(fs.readFileSync(claudeJsonFilePath, 'utf-8'));
    fs.writeFileSync(claudeJsonFilePath, JSON.stringify({ ...content, penguinModeOrgEnabled: true, hasCompletedOnboarding: true }, null, 2), 'utf-8');
} else {
    fs.writeFileSync(claudeJsonFilePath, JSON.stringify({ penguinModeOrgEnabled: true, hasCompletedOnboarding: true }), 'utf-8');
}

// delete old model id
const claudeSettingsJsonFilePath = path.join(os.homedir(), '.claude', 'settings.json');
if (fs.existsSync(claudeSettingsJsonFilePath)) {
    const content = JSON.parse(fs.readFileSync(claudeSettingsJsonFilePath, 'utf-8'));
    if (typeof content === 'object' && typeof content.env === 'object') {
        for (const element of [
            'ANTHROPIC_MODEL',
            'ANTHROPIC_SMALL_FAST_MODEL',
            'CLAUDE_CODE_SUBAGENT_MODEL',
            'ANTHROPIC_DEFAULT_FABLE_MODEL',
            'ANTHROPIC_DEFAULT_FABLE_MODEL_NAME',
            'ANTHROPIC_DEFAULT_OPUS_MODEL',
            'ANTHROPIC_DEFAULT_OPUS_MODEL_NAME',
            'ANTHROPIC_DEFAULT_SONNET_MODEL',
            'ANTHROPIC_DEFAULT_SONNET_MODEL_NAME',
            'ANTHROPIC_DEFAULT_HAIKU_MODEL',
            'ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME',
        ]) {
            delete content.env[element];
        }
        fs.writeFileSync(claudeSettingsJsonFilePath, JSON.stringify(content, null, 2), 'utf-8');
    }
}
"

Étape 3 — la configuration officielle : des variables d'environnement exportées, pas un bloc env dans settings.json. Selon votre offre, les modèles et la fenêtre de contexte disponibles changent :

Configuration « K3 avec 1M de contexte » (Allegretto et au-dessus) :

export ANTHROPIC_BASE_URL=https://api.kimi.com/coding/
export ANTHROPIC_API_KEY=VotreCleAPI

export ANTHROPIC_MODEL="k3[1m]"
export ANTHROPIC_DEFAULT_FABLE_MODEL=$ANTHROPIC_MODEL
export ANTHROPIC_DEFAULT_OPUS_MODEL=$ANTHROPIC_MODEL
export ANTHROPIC_DEFAULT_SONNET_MODEL=$ANTHROPIC_MODEL
export ANTHROPIC_DEFAULT_HAIKU_MODEL=$ANTHROPIC_MODEL
export CLAUDE_CODE_SUBAGENT_MODEL=$ANTHROPIC_MODEL
export CLAUDE_CODE_EFFORT_LEVEL=high
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576
export CLAUDE_CODE_MAX_CONTEXT_TOKENS=1048576

claude

La forme "k3[1m]" n'existe que là : comme valeur de variable d'environnement Claude Code, entre guillemets, pour déverrouiller la fenêtre d'1M de jetons. Partout ailleurs — requêtes API, champ « Model ID » des autres outils — l'identifiant est k3. Si votre offre ne donne K3 qu'en 256k, utilisez ANTHROPIC_MODEL=k3 et réglez CLAUDE_CODE_AUTO_COMPACT_WINDOW et CLAUDE_CODE_MAX_CONTEXT_TOKENS à 262144.

3.2 Les pièges (ce qui m'a fait perdre du temps, pour que vous ne le perdiez pas)

1. Une seule variable d'authentification : la documentation officielle n'utilise que ANTHROPIC_API_KEY. Ne mélangez pas avec d'anciennes variables (ANTHROPIC_AUTH_TOKEN, restes d'un bloc env) — le script de l'étape 2 est là pour ça.
2. Couper le « thinking » reroute K3 vers K2.6 : gardez le raisonnement activé pour rester sur K3 / K2.7. L'effort se règle en session avec /effort, sans variable d'environnement. Correspondance des niveaux : low → low, medium et high → high, xhigh et max → max (non réglé : high).
3. Chaque variable de tier non configurée = un échec silencieux du scénario correspondant (sous-agents, résumé, etc.). Tout doit être mappé.
4. Tester avant de lancer : un curl sur l'endpoint valide la clé en 10 s ; ensuite /status dans Claude Code doit afficher Base URL https://api.kimi.com/coding/. Le menu /model et /status peuvent continuer d'afficher des noms de modèles Claude : c'est normal, les appels partent bien vers l'API Kimi Code.
5. Si 400 persistant : ajouter ENABLE_TOOL_SEARCH=false.
6. Clés UE vs Chine : platform.kimi.ai (international) et platform.kimi.com (Chine) sont deux silos — une clé de l'un renvoie 401 sur l'autre.

3.3 Le swarm : n8n en chef d'orchestre

Au-dessus de Claude Code, le swarm tourne sous n8n, sur le laptop : chaque workflow lit la matrice de routing §2, délègue au bon backend — Kimi, un modèle local du rig, ou LFM3 — et journalise coût et latence par tâche. C'est ce journal qui rend la matrice honnête : une route qui coûte trop ou qui échoue trop se voit, et elle change. Le détail des workflows relève de la série « votre stack d'agents » ; ici, la seule chose à retenir est que le router est un outil déterministe, pas un agent qui décide au feeling.

4. Ce que je mesure — et ce que je refuse de publier

Je ne publierai pas de tableau A/B Claude vs Kimi avec des notes de qualité : je n'ai pas fait tourner ce benchmark, et un tableau inventé vaudrait moins que n'importe quel benchmark de blogueur. Ce que je mesure vraiment :

• La continuité de travail. En septembre et octobre, les plafonds Claude ont coupé des runs en plein milieu, à répétition — les 108,76 € puis 145,20 € de recharges sont là pour le prouver. En novembre, une seule rupture côté Kimi (voir §5). C'est ça, mon critère : le nombre de fois où le travail s'arrête sans que je l'aie décidé.
• Le coût réel, facture par facture : le tableau d'ouverture.
• Le débit local, mesuré en production : la table du §2.
• La qualité des modèles locaux, produite par fh-bench — tâches jugées programmatiquement, une carte de capacités — pas par une impression d'utilisateur.

5. Ce que j'ai perdu (aussi important que le reste)

• Le plafond existe aussi chez Kimi. En Ultra, la limite mensuelle du cycle a été atteinte en pleine session — un 429 sec, vécu le 3 novembre 2026. La différence n'est pas « plafond vs pas de plafond », c'est la fréquence et la lisibilité : un seul palier à surveiller au lieu d'un abonnement plus des recharges.
• Le cadrage est moins pardonnant. Mal briefé, K3 part en verbosité ; il faut des system prompts stricts (la méthode Disler : contrats de communication explicites, patterns positifs et négatifs) là où Claude tient le style plus naturellement. Le travail de cadrage ne disparaît pas, il se déplace dans les prompts.
• L'écosystème tiers est plus pauvre. Moins d'outillage prêt à l'emploi, et l'endpoint compatible Anthropic a dû être câblé moi-même dans chaque outil de la chaîne — la procédure du §3 existe parce qu'elle n'était écrite nulle part pour mon cas.

6. Pour qui (et pour qui pas)

• Abonné Claude léger, usage occasionnel → ne bougez pas. La migration se justifie à partir d'un certain volume — mes 385,96 € sur deux mois ne sont pas votre référence.
• Usage API intensif, besoins de long contexte, projet hybride local/frontier → le test vaut le coup. Commencez par un mois en parallèle, publiez vos mesures.

Sources

• Kimi Code, configuration des agents tiers (Claude Code) — documentation officielle
• Moonshot AI, tarifs officiels de l'API
• freedzhost.cloud, le tutoriel Kimi Code
• freedzhost.cloud, turnstile, l'allocateur GPU

Prix constatés le 2 novembre 2026 — les tarifs bougent vite des deux côtés. Transparence : aucune relation avec Moonshot AI ; cet article n'est pas sponsorisé ; chiffres réels de mes factures. Article sous licence CC BY-SA 4.0, comme le reste de freedzhost.cloud.

Utile ? Dites-nous ce qu'il faut mesurer ensuite.