Guide

Kimi K3 : le modèle à poids ouverts qui a comblé l'écart

Kimi K3 de Moonshot AI est un modèle à poids publics, mixture d'experts, 1 million de tokens de contexte. Licence, API, matériel, tarifs et comparaisons.

L'équipe CodeWorlds17 min de lecture ·

Pratique Vibe coding avec Claude Code dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article12

Moonshot AI a publié Kimi K3 à la mi-juillet 2026 et a mis en ligne les poids complets onze jours plus tard. C'est un modèle de type mixture d'experts d'environ deux virgule huit mille milliards de paramètres au total et à peu près cent quatre milliards actifs pendant la génération, avec une fenêtre de contexte qui atteint un million de tokens.

Les chiffres impressionnent, et le plus important est autre : c'est un modèle aux poids publics qui égale les meilleurs modèles fermés sur certaines tâches, en particulier le code et le travail agentique. Jusqu'à récemment, ces deux propriétés s'excluaient mutuellement.

Ce que cela signifie en pratique

Une architecture de mixture d'experts signifie qu'une fraction des paramètres travaille sur chaque token. Le modèle calcule aussi vite qu'un modèle de cent milliards de paramètres tout en tirant sa qualité de l'ensemble.

Une conséquence pratique mérite d'être connue avant de planifier le matériel. Tout doit être chargé en mémoire, pas seulement la partie active. Un modèle de deux virgule huit mille milliards de paramètres, même dans sa quantification native en quatre bits, demande au minimum un nœud contenant huit cartes de centre de données, et pour un vrai trafic de production le fournisseur recommande une configuration multi-nœuds. Le faire tourner sur un ordinateur portable est hors de question.

Un million de tokens de contexte te permet de déposer dans une requête tout un dépôt de taille moyenne ou plusieurs centaines de pages de documentation. Cela change la façon de faire le travail d'analyse, et cela a un coût : traiter cette entrée prend du temps et des tokens, donc la recherche documentaire reste préférable pour les requêtes répétées.

Le modèle est aussi nativement multimodal : il comprend le texte, les images et la vidéo en une seule passe, sans modèle de vision séparé greffé dessus. Le raisonnement est activé en permanence, donc une réponse porte la trace du raisonnement en plus de la réponse proprement dite, et tu ne règles que sa profondeur.

La licence

C'est la première chose à vérifier et la plus souvent ignorée avec les modèles de cette partie du monde.

Les poids sont publics, mais la licence est sur mesure, basée sur une licence permissive avec des conditions supplémentaires. À grande échelle d'exploitation, mesurée par le nombre d'utilisateurs ou le chiffre d'affaires, apparaît l'obligation de marquer le produit avec le nom du modèle. Pour la plupart des entreprises, cette condition est sans importance ; pour une grande plateforme grand public, elle ne l'est pas.

Les seuils sont énoncés clairement : l'obligation de mentionner le nom s'applique à un produit de plus de cent millions d'utilisateurs actifs mensuels ou de plus de vingt millions de dollars de chiffre d'affaires mensuel. Une condition distincte, plus stricte, couvre le fait de proposer le modèle lui-même comme service : une entreprise qui exerce une telle activité et dépasse vingt millions de dollars de chiffre d'affaires sur douze mois consécutifs quelconques doit conclure un accord séparé avec le fournisseur avant tout usage commercial.

Les deux conditions comportent une exemption qui, en pratique, couvre la plupart des déploiements. Aucune ne s'applique à l'usage interne, c'est-à-dire un usage où ni le modèle ni ses capacités ne sont mis à la disposition de tiers, ni à l'accès via les produits officiels du fournisseur et ses partenaires certifiés.

La conclusion pratique rejoint celle d'autres modèles ouverts par des entreprises commerciales : lis le texte de la licence avant d'intégrer le modèle dans un produit. Le mot « ouvert » dans les documents marketing ne signifie pas que les conditions correspondent à une licence permissive sans réserve.

Si tu as besoin d'une licence sans conditions supplémentaires, la bonne direction est celle des modèles publiés sous une licence permissive classique, ceux de Mistral par exemple.

Travailler via l'API

L'interface suit un format populaire, donc l'intégration se résume à changer l'adresse et le nom du modèle.

Python
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MOONSHOT_API_KEY"],
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Analyse this module and name its weak points: ..."}],
)

Cette compatibilité compte en pratique pour comparer. Le même code avec un autre nom de modèle et une autre adresse te permet de passer tes propres cas dans plusieurs modèles et de comparer les résultats au lieu de t'appuyer sur les benchmarks de quelqu'un d'autre.

Deux choses s'écartent toutefois d'un appel typique, et toutes deux peuvent te surprendre lors d'une première intégration. La première est un raisonnement qu'on ne peut pas désactiver ; tu ne règles que sa profondeur, via le champ reasoning_effort, qui prend low, high et max, avec la valeur la plus haute par défaut. Descendre à low sur le travail courant réduit le coût et la latence plus que n'importe quel changement de prompt.

La seconde est la façon dont une conversation est transportée. Le modèle a été entraîné avec l'historique du raisonnement conservé, donc aux tours suivants et lors des appels d'outils tu dois renvoyer le message complet de l'assistant, trace de raisonnement comprise, plutôt que le seul texte de la réponse.

Python
history = [{"role": "user", "content": "Tell me three random numbers."}]

response = client.chat.completions.create(
    model="kimi-k3",
    messages=history,
    reasoning_effort="low",
)

history.append(response.choices[0].message.model_dump(exclude_none=True))
history.append({"role": "user", "content": "What are the other two you had in mind?"})

Sauter cette étape ne renvoie aucune erreur et dégrade silencieusement les résultats : le modèle perd son propre raisonnement du tour précédent et, sur des séquences plus longues, commence à abandonner des conclusions qu'il avait déjà atteintes.

La grille tarifaire officielle porte deux tarifs d'entrée et un tarif de sortie, et l'écart entre les tarifs d'entrée est de un à dix. Un million de tokens d'entrée coûte 0,30 USD en cas de succès du cache de contexte et 3 USD en cas d'échec, tandis qu'un million de tokens de sortie coûte 15 USD. C'est exactement le territoire de Claude Sonnet 5 plutôt qu'une fraction des prix des modèles fermés de pointe, et un bond abrupt par rapport aux modèles précédents du même fournisseur. Il ne revient bon marché qu'à côté des modèles fermés les plus puissants, donc l'argument en faveur de celui-ci est l'accès aux poids plutôt que le tarif lui-même.

Une condition d'entrée figure à côté dans la grille tarifaire : le modèle ne se débloque qu'après avoir crédité le compte d'au moins un dollar, et le total cumulé des recharges détermine les limites de requêtes et de tokens par minute et par jour. Vérifie quand même la grille tarifaire actuelle à la source, car les tarifs des modèles ouverts changent plus souvent que ceux des modèles fermés.

Le faire tourner soi-même

Comme les poids sont publics, le modèle peut tourner sur ta propre infrastructure. Il suffit de savoir ce que cela implique.

Les poids complets demandent des machines serveur avec de nombreuses cartes et une pile de service qui prend en charge l'inférence distribuée. Ce n'est pas une installation d'un après-midi mais un projet d'infrastructure. Sans ce travail préparatoire, la bonne voie est la location auprès d'un fournisseur qui propose ce modèle, ce qui préserve l'indépendance vis-à-vis d'une seule société.

Les variantes plus petites et quantifiées publiées par la communauté abaissent les exigences au prix de la qualité. C'est un compromis raisonnable pour les tâches où la confidentialité des données compte plus que la précision maximale.

Les poids eux-mêmes tournent sur trois serveurs d'inférence que le fournisseur nomme, et en démarrer un se résume à une seule commande qui expose une interface dans le même format que l'API officielle. L'exemple ci-dessous utilise vLLM, car il regroupe les requêtes entrantes à la volée et donc maintient le débit sur de nombreuses conversations simultanées au lieu de les servir l'une après l'autre.

Bash
vllm serve moonshotai/Kimi-K3 \
  --served-model-name kimi-k3 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --api-key "$LOCAL_KEY"

Le nombre de cartes dans l'option de parallélisme et la longueur du contexte dépendent du matériel dont tu disposes, donc prends la topologie précise dans la recette publiée pour ce modèle plutôt que de deviner. Les poids sont nativement quantifiés, puisque la quantification a été intégrée pendant l'entraînement, donc elle n'a pas besoin d'être ajoutée comme étape séparée et ne porte pas la pénalité de qualité habituelle.

Ramener le contexte d'un million de tokens à ce que tu utilises réellement est le moyen le plus simple de réduire l'exigence de mémoire ici. Le serveur réserve de la place pour la conversation la plus longue autorisée, donc déclarer un million de tokens dans un service qui traite des requêtes de dix mille tokens est une prudence coûteuse.

Plus de détails sur l'exécution locale de modèles se trouvent dans l'article sur Ollama, en gardant à l'esprit qu'un outillage mono-utilisateur ne fournira pas le débit dont de nombreux utilisateurs ont besoin.

Louer plutôt que d'avoir sa propre infrastructure

Puisque faire tourner soi-même les poids complets est un projet plutôt qu'une installation, la voie intermédiaire mérite d'être connue.

Les fournisseurs cloud qui proposent des modèles à poids publics facturent au token, comme pour les modèles fermés, et tu conserves deux choses. La première est la possibilité de passer à un autre fournisseur du même modèle, puisque les poids sont publics, donc tu n'es pas lié à une seule société. La seconde est la possibilité de passer sur ta propre infrastructure quand le volume le justifie.

Cette différence est sous-estimée. Un modèle fermé signifie que, lors d'un changement de prix ou d'un retrait de version, tes options sont la migration ou l'acceptation. Un modèle à poids publics donne une troisième option, et sa seule existence change ta position de négociation.

Vérifie toutefois ce qu'un fournisseur propose réellement. Les mêmes poids servis par des piles différentes donnent une latence différente, des limites de contexte différentes et un comportement différent pour les appels d'outils. Un nom de modèle seul ne permet pas de supposer des résultats identiques.

Traitement parallèle

Les tâches où de nombreux appels s'exécutent à la fois sont un schéma de travail à part entière, qu'il vaut la peine de connaître avant d'essayer de raccourcir le temps de réponse autrement.

Une tâche d'agent divisée en une douzaine de sous-tâches indépendantes exécutées en série prend douze fois plus de temps qu'une seule. Les exécuter en parallèle ramène le temps réel à celui de la plus longue, au prix d'une consommation instantanée plus élevée.

Ce schéma convient à la revue de nombreux fichiers à la fois, à la vérification de plusieurs hypothèses et au traitement par lots où chaque élément est indépendant. Il ne convient pas aux étapes qui dépendent les unes des autres, car le parallélisme n'a alors rien à accélérer.

Surveille aussi le coût. Dix appels parallèles coûtent autant que dix appels en série, seulement plus vite. L'économie porte sur le temps plutôt que sur l'argent, donc sur les tâches où personne n'attend, le parallélisme n'apporte qu'un pic de consommation.

À quoi il sert

Trois domaines reviennent dans les applications de ce modèle et valent d'être connus avant de commencer à comparer.

Le premier est le travail sur le code. Sur les benchmarks qui mesurent la résolution réelle de tickets dans des dépôts, le modèle se comporte comme les leaders fermés, ce qui aurait été une surprise il y a un an. Sur des tâches qui couvrent de nombreux fichiers et de longues sessions, cet avantage se remarque.

Le deuxième est le travail agentique. Le modèle est conçu pour l'appel d'outils et les longues séquences d'étapes, ce qui était souvent un point faible des modèles ouverts.

Le troisième est l'analyse de longs documents. Un million de tokens de contexte lui permet de lire d'un coup tout un contrat, une spécification ou un vidage de journaux, sans découpage et sans système de recherche à construire.

La langue reste la limite. Les modèles de cette partie du monde fonctionnent le mieux en anglais et en chinois et sont généralement plus faibles ailleurs, donc avec du contenu dans une autre langue un test sur tes propres exemples est obligatoire.

Données et conformité

Avec un modèle d'un fournisseur hors de ta juridiction, une question se pose à laquelle les poids publics répondent de façon inhabituelle.

Utiliser l'interface officielle signifie envoyer du contenu aux serveurs du fournisseur, selon des conditions et un lieu de données qu'il détermine. Avec des données personnelles ou des secrets d'affaires, cela doit être vérifié avant le déploiement, exactement comme avec n'importe quel autre fournisseur externe.

Les poids publics offrent pourtant une sortie qu'un modèle fermé n'offre pas. Le même modèle exécuté chez un fournisseur dans une région choisie ou sur ta propre infrastructure traite les données là où les exigences le permettent. La question du transfert de données cesse alors de concerner le modèle et ne concerne plus que l'infrastructure.

C'est un schéma récurrent dans les organisations réglementées. Un projet démarre sur l'interface du fournisseur parce que c'est le plus rapide, et après le premier audit une partie du pipeline passe sur un modèle exécuté ailleurs. Prévois cette séparation dès le départ, car une fine couche avec une seule forme d'appel fait du changement un travail d'une journée.

Comment le comparer à ton modèle actuel

Les benchmarks publics mesurent des tâches qui ressemblent rarement aux tiennes, donc fais la comparaison toi-même. Elle prend un après-midi et donne une réponse sur laquelle une décision peut s'appuyer.

Commence par trente vrais cas du dernier mois de travail. Ils doivent couvrir des tâches faciles, des tâches difficiles et des cas où ta solution actuelle a échoué, car ce sont ceux qui séparent le plus les modèles.

Passe-les dans deux ou trois modèles avec un prompt identique et note les résultats côte à côte. Lire vingt réponses dans un tableau en dit plus que n'importe quel chiffre, car tu vois non seulement si une réponse est correcte mais aussi comment elle se lit.

Ajoute un chiffre pour les parties mesurables : part de cas résolus correctement, temps de réponse et coût par exécution. Des outils comme Promptfoo le font pour toi et comparent les modèles sur le même jeu avec une seule commande.

La configuration tient en une douzaine de lignes, car une interface qui suit le format familier te permet de déclarer ce modèle comme un fournisseur ordinaire en changeant l'adresse.

YAML
providers:
  - id: openai:chat:kimi-k3
    config:
      apiBaseUrl: https://api.moonshot.ai/v1
      apiKeyEnvar: MOONSHOT_API_KEY
  - id: anthropic:messages:claude-sonnet-5

prompts:
  - file://prompts/analysis.txt

tests:
  - vars:
      ticket: "Payment went through but the order was cancelled"
    assert:
      - type: contains
        value: refund

Le même fichier exécuté un mois plus tard te dit si quelque chose a bougé, et avec des modèles développés rapidement cela bouge plus souvent que la plupart des équipes ne le supposent. C'est le principal avantage d'un jeu enregistré sur l'évaluation à l'œil : il peut être répété.

Kimi face aux alternatives

ModèlePoint fortPoint faibleÀ choisir quand
Kimi K3Poids publics, code et agents, contexte d'un million de tokensExigences matérielles énormes, licence conditionnelleTravail de code à gros volume, exigence d'indépendance
LlamaPlus grand écosystème d'outils et de variantesLicence sur mesure, plus faible sur le codeFine-tuning et outillage prêt à l'emploi
MistralLicence permissive, langues européennesÉchelle de modèle plus petiteExigence d'une licence sans condition
ClaudeTravail sur le code, longues tâches agentiquesPas de poids, facturation au tokenTâches difficiles où la qualité décide

Choisir parmi les lignes revient à trois questions : as-tu besoin des poids, quel matériel as-tu et dans quelle langue travailles-tu. Un modèle à poids publics que tu n'as nulle part où faire tourner donne exactement ce que donne un modèle fermé, seulement avec un moins bon support.

Rappelle-toi aussi qu'une avance dans un benchmark ne se transpose pas directement à tes tâches. Trente vrais cas passés dans deux modèles en disent plus que n'importe quel classement et prennent un après-midi.

L'arrangement le plus sensé sur un déploiement plus large est en fait d'utiliser plusieurs modèles à la fois. Le travail en volume et simple va au modèle moins cher, le travail difficile au plus puissant, et le choix se fait dans la couche qui route le trafic. Les poids publics aident précisément ici, car ils te permettent de pourvoir le premier rôle sans payer au token.

Erreurs courantes

La première est de planifier le matériel d'après le nombre de paramètres actifs. Tout entre en mémoire, donc la vitesse de génération ne réduit pas les besoins en mémoire.

La deuxième est de sauter la licence. Des poids publics ne signifient pas une licence permissive sans réserve, et les conditions à grande échelle méritent d'être connues avant d'intégrer le modèle dans un produit.

La troisième est de supposer qu'un résultat de benchmark se transpose à ton domaine. Les différences entre modèles dépendent de la langue, du style de code et du type de tâche plus que de la position dans le classement.

La quatrième est de déposer un million de tokens de contexte dans des requêtes répétées. À cent questions par jour, la recherche dans une base vectorielle revient bien moins cher et plus vite.

La cinquième est de sauter un test dans ta propre langue. C'est là que les modèles de cette famille sont moins bons qu'en anglais, et l'écart dépasse parfois celui entre deux générations.

La sixième est de n'avoir aucune couche qui sépare la logique du fournisseur. La compatibilité d'interface ne facilite le changement que si ton code appelle une seule fonction à toi plutôt que le client d'une société précise à vingt endroits.

FAQ

Qu'est-ce que Kimi K3 ?

Un modèle de langage de Moonshot AI avec une architecture de mixture d'experts, environ deux virgule huit mille milliards de paramètres au total et une fenêtre de contexte jusqu'à un million de tokens. Publié à la mi-juillet 2026, avec des poids publiés publiquement fin du même mois.

Les poids sont-ils réellement disponibles ?

Oui, bien que la licence soit sur mesure, basée sur une licence permissive avec des conditions supplémentaires. À grande échelle d'exploitation, une obligation de mention du produit apparaît. Pour la plupart des applications, c'est sans importance ; avant d'intégrer le modèle dans un produit, lis le texte de la licence.

Quel matériel faut-il ?

Les poids complets demandent une infrastructure serveur avec de nombreuses cartes, donc le faire tourner soi-même est un projet plutôt qu'une installation. L'alternative réaliste est de louer auprès d'un fournisseur qui propose ce modèle ou de prendre des variantes quantifiées aux exigences plus faibles et à la qualité moindre.

Est-il bon pour le travail sur le code ?

Oui, et c'est son point le plus fort. Sur les benchmarks qui mesurent la résolution réelle de tickets, il se comporte comme les principaux modèles fermés. Sur ton propre dépôt, vérifie-le sur quelques dizaines de tâches, car les différences dépendent du langage de programmation.

Comment gère-t-il les langues autres que l'anglais ?

Moins bien que l'anglais, ce qui vaut pour la plupart des modèles en dehors de la sphère d'une langue donnée. Pour des applications dans une autre langue, compare-le à un modèle européen sur tes propres exemples avant de décider.

Le modèle et la licence sont décrits sur le site de Moonshot AI, et une analyse de la sortie figure dans l'article de Simon Willison.

À lire aussi