TL;DR
Grok Build 0.1 est le modèle d’xAI spécialisé en programmation pour l’ingénierie logicielle agentique, plutôt que pour des conversations de chatbot ordinaires. Mis à disposition en bêta publique via l’API xAI le 29 mai 2026, il se concentre sur le développement web, le débogage, l’appel d’outils, les flux MCP et les agents de codage autonomes.
Le modèle offre une fenêtre de contexte de 256,000 jetons, accepte des entrées texte et image, prend en charge le raisonnement, les sorties structurées et l’appel de fonctions, et coûte 1 $ par million de jetons d’entrée et 2 $ par million de jetons de sortie au tarif standard. Son point fort n’est pas une complétion de code isolée, mais un flux de travail en plusieurs étapes dans lequel un agent inspecte un dépôt, modifie des fichiers, appelle des outils, exécute des tests et itère jusqu’à un résultat validé.
La distinction clé est simple : Grok Build est le produit d’agent de codage, tandis que grok-build-0.1 est le modèle accessible via API qui peut s’exécuter dans d’autres harnais de codage agentique. L’API Grok Build 0.1 dans CometAPI est également disponible, fournissant le même identifiant de modèle via une passerelle compatible OpenAI.
Points clés
- Grok Build 0.1 est optimisé pour la programmation agentique, le travail sur dépôts, le débogage et l’ingénierie logicielle pilotée par les outils.
- Son identifiant de modèle API est
grok-build-0.1, avec une fenêtre de contexte de 256K et une entrée texte et image. - La tarification xAI à contexte court est de 1 $/M en entrée, 0,20 $/M en entrée mise en cache, et 2 $/M en sortie. L’API Grok Build 0.1 dans CometAPI est 20 % moins chère à 0,80 $/M en entrée, 0,16 $/M en entrée mise en cache, et 1,60 $/M en sortie ; les requêtes au seuil de 200K ou au-delà utilisent des tarifs de contexte long plus élevés.
- Il prend en charge le raisonnement, l’appel de fonctions et les sorties structurées, mais ne prend pas en charge l’API Batch.
- Évaluez-le par le coût et le temps par tâche d’ingénierie réussie, et non par le prix du jeton brut ou un seul benchmark.
Qu’est-ce que Grok Build 0.1 ?
Grok Build 0.1 est un modèle de langage xAI spécialisé, conçu autour des flux de travail d’ingénierie logicielle agentique. D’après xAI, il a été entraîné pour des tâches telles que le développement web, le débogage et les agents de codage compatibles MCP, et il a alimenté l’environnement de codage Grok Build d’origine.
Ce positionnement le distingue d’un assistant généraliste conventionnel. Un agent de codage doit inspecter de façon répétée un dépôt, identifier les fichiers pertinents, appeler des outils, éditer le code, exécuter des tests, lire les échecs et réviser l’implémentation sans perdre l’état de la tâche.
Pour cette raison, l’unité d’évaluation pertinente est une tâche d’ingénierie de bout en bout : navigation dans le dépôt → plan → modification → exécution d’outils → reprise après échec → validation.
Grok Build 0.1 est-il identique à Grok Build ?
Non. Grok Build est l’agent de codage en terminal d’xAI, tandis que Grok Build 0.1 est un modèle sous-jacent que les développeurs peuvent invoquer via l’API.
Grok Build inclut la revue de plans, les diffs de code, la prise en charge de AGENTS.md, des plugins, hooks, compétences, serveurs MCP, sous-agents parallèles, l’intégration worktree et un mode sans interface pour l’automatisation. Le modèle peut aussi être utilisé en dehors de ce produit en terminal dans des frameworks d’agents et des passerelles compatibles.
Quelles sont les spécifications de Grok Build 0.1 ?
| Spécification | Grok Build 0.1 |
|---|---|
| Développeur | xAI / SpaceXAI |
| Identifiant du modèle | grok-build-0.1 |
| Objectif principal | Programmation agentique et ingénierie logicielle |
| Entrée / sortie | Entrée texte et image ; sortie texte |
| Fenêtre de contexte | 256,000 jetons |
| Capacités | Raisonnement, appel de fonctions, sorties structurées |
| Tarification standard par jeton | 1,00 $/M en entrée ; 0,20 $/M en entrée en cache ; 2,00 $/M en sortie |
| Seuil de contexte long | 200K jetons d’invite |
| Tarification pour contexte long | 2,00 $/M en entrée ; 0,40 $/M en entrée en cache ; 4,00 $/M en sortie |
| API Batch | Non pris en charge |
| Limites documentées | 37 requêtes/s ; 10,000,000 jetons/min |
| Régions | us-east-1, us-west-2 |
Ces spécifications sont documentées sur la page officielle du modèle xAI. La fenêtre de contexte de 256K peut contenir un important contexte de dépôt, tandis que l’entrée image permet à un agent d’interpréter des captures d’écran, maquettes, diagrammes d’architecture et rapports de bugs visuels en plus du code source.
Une fois qu’une invite atteint le seuil de contexte long, des tarifs plus élevés s’appliquent à tous les jetons de cette requête. Les agents fortement axés sur les dépôts devraient donc compacter ou récupérer sélectivement le contexte plutôt que d’ajouter continuellement des fichiers et des sorties d’outils.
Qu’est-ce qui différencie Grok Build 0.1 ?
La programmation agentique comme cible d’optimisation principale
Grok Build 0.1 n’est pas seulement un modèle capable d’écrire du Python ou du JavaScript. Sa spécialisation porte sur l’interaction entre raisonnement, génération de code et outils. Un agent de codage utile doit planifier, inspecter, modifier, exécuter, se remettre des échecs et continuer sans perdre l’état de la tâche.
Des flux d’outils orientés MCP
Les flux orientés MCP peuvent connecter un agent de codage à des bases de données, systèmes de déploiement, dépôts de documentation, traqueurs d’incidents, systèmes d’observabilité et outils internes des développeurs via des interfaces standardisées.
Automatisation structurée
Les sorties structurées sont utiles lorsqu’un agent doit renvoyer des objets prévisibles plutôt que du texte libre — par exemple, des plans de modifications de fichiers, des paramètres d’outils, des résultats de tests, des constats de revue ou des décisions de déploiement. Cela réduit les parsings fragiles entre le modèle et la couche d’orchestration.
Contexte visuel pour le web et l’interface utilisateur
Comme le modèle accepte l’entrée image, un agent peut travailler avec des captures d’écran, des pages rendues, des références d’interface, des boîtes de dialogue d’erreur et des diagrammes d’architecture en plus du code source.
Quelle est la rapidité de Grok Build 0.1 ?
xAI a décrit Grok Build 0.1 comme son modèle de codage le plus rapide au lancement et a annoncé plus de 100 jetons de sortie par seconde. Il s’agit d’une affirmation de service officielle, pas d’une garantie pour chaque invite ou point de terminaison.
Les mesures indépendantes doivent être considérées comme des observations horodatées. Artificial Analysis rapporte actuellement environ 69.6 jetons/s en sortie et 0.54 seconde de temps jusqu’au premier jeton pour l’API SpaceXAI. L’infrastructure du fournisseur, la longueur de l’invite, le comportement de raisonnement, l’utilisation des outils et la charge serveur peuvent tous modifier le résultat.
Comment interpréter les benchmarks ?
| Indicateur indépendant | Valeur rapportée actuelle | Interprétation |
|---|---|---|
| Artificial Analysis Intelligence Index | 27, estimé | Estimation composite ; l’évaluation indépendante est encore indiquée comme à venir |
| Vitesse de sortie | 69.6 jetons/s | Mesurée sur l’API SpaceXAI de première partie après le premier segment de réponse |
| Temps jusqu’au premier jeton | 0.54 s | Mesure de la latence du point de terminaison ; pas le temps total d’achèvement de la tâche |
Ces chiffres ont été vérifiés sur Artificial Analysis le 22 septembre 2026. Comme la page est mise à jour dynamiquement, les révisions futures devraient vérifier à nouveau les valeurs et conserver la date de vérification.
Pour les systèmes de codage autonomes, les scores de benchmark ne sont qu’une partie de l’évaluation. La navigation dans le dépôt, la précision des modifications, la sélection des outils, le comportement de reprise, la discipline de test, la latence et l’utilisation totale des jetons peuvent compter davantage pour la productivité des développeurs.
Combien coûte Grok Build 0.1 ?
Grok Build 0.1 utilise des tarifs distincts pour les contextes courts et longs. Le palier à contexte court s’applique lorsque la longueur de l’invite est inférieure à 200,000 jetons ; une fois que la requête atteint ce seuil, le tarif plus élevé de contexte long s’applique à la requête.
| Niveau de tarification | CometAPI | xAI officiel |
|---|---|---|
| Entrée à contexte court | 0.80 $/M | 1.00 $/M |
| Entrée à contexte court mise en cache | 0.16 $/M | 0.20 $/M |
| Sortie à contexte court | 1.60 $/M | 2.00 $/M |
| Entrée à contexte long | 1.60 $/M | 2.00 $/M |
| Entrée à contexte long mise en cache | 0.32 $/M | 0.40 $/M |
| Sortie à contexte long | 3.20 $/M | 4.00 $/M |
Aux tarifs de contexte court, un million de jetons d’entrée plus un million de jetons de sortie coûtent 2.40 $ via CometAPI, contre 3.00 $ via l’API xAI officielle. Aux tarifs de contexte long, le même mix de jetons coûte 4.80 $ via CometAPI contre 6.00 $ via xAI. Ces montants ne couvrent que les jetons du modèle ; les budgets de production doivent également inclure les appels d’outils, les réessais, l’exécution des tests et la surcharge d’orchestration.
Grok Build 0.1 vs Grok 4.7 vs Grok Code Fast 1
| Dimension | Grok Build 0.1 | Grok 4.7 | Grok Code Fast 1 |
|---|---|---|---|
| Cycle de vie | Modèle spécialisé en codage actuel | Modèle de pointe actuel | Modèle de codage de génération précédente ; retiré le 15 mai 2026 |
| Positionnement principal | Modèle spécialisé de programmation agentique | Codage de pointe, tâches agentiques et travail de connaissance | Modèle de codage rapide et prédécesseur de la lignée de modèles de codage d’xAI |
| Fenêtre de contexte | 256K | 500K | Spécification héritée ; à ne pas utiliser comme base pour un nouveau déploiement |
| Raisonnement et outils | Raisonnement, appel de fonctions, sorties structurées | Raisonnement configurable ; appel de fonctions, recherche web, recherche X, et exécution de code | Flux de codage hérités ; migrer plutôt qu’étendre un usage de production |
| Tarification officielle entrée/sortie à contexte court | 1.00 / 2.00 $ par M jetons | 2.00 / 6.00 $ par M jetons | Retiré ; aucun tarif de production actuel à supposer |
| Tarification CometAPI entrée/sortie à contexte court | 0.80 / 1.60 $ par M jetons | 1.60 / 4.80 $ par M jetons | Utiliser le catalogue actuel et le modèle de remplacement plutôt que le slug retiré |
| Tarification officielle entrée/sortie à contexte long | 2.00 / 4.00 $ par M jetons | 4.00 / 12.00 $ par M jetons | Non applicable comme tarif de sélection de modèle actuel |
| Cas d’usage typique | Boucles intensives sur dépôts, débogage, et agents de codage sensibles au coût | Tâches de codage plus difficiles et plus longues et workflows professionnels nécessitant un raisonnement de pointe plus fort et plus de contexte | Référence de migration uniquement ; épingler grok-build-0.1 pour les charges de codage actuelles |
Grok Build 0.1 est le spécialiste plus économique lorsque l’inspection répétée de dépôts, l’édition et les tests dominent la charge. Grok 4.7 offre près du double de contexte et un profil de capacité de pointe plus large, mais son prix par jeton de sortie est nettement plus élevé. La décision pratique doit se baser sur le coût par tâche réussie, y compris les réessais, les appels d’outils et le temps de correction humaine.
Les deux modèles sont disponibles dans CometAPI, permettant aux équipes d’exécuter les mêmes tâches de codage via une seule passerelle et de comparer le taux d’achèvement, la latence, l’utilisation du contexte et le coût total dans un harnais cohérent.
Quel lien entre Grok Build 0.1 et Grok Code Fast 1 ?
L’identifiant grok-code-fast-1 était inclus dans le retrait de modèles d’xAI du 15 mai 2026. Le guide de migration contient une mention générale selon laquelle les slugs retirés redirigent vers grok-4.3, tandis que son tableau de remplacement spécifique au modèle et la section « Code workloads » recommandent grok-build-0.1 et indiquent que le slug de codage est routé vers ce modèle.
Comme le même guide officiel décrit la redirection à deux niveaux, les utilisateurs de production ne devraient pas traiter le slug retiré comme un identifiant de modèle stable. Épinglez explicitement grok-build-0.1 pour les charges de travail de codage et vérifiez le routage actuel avant le déploiement.
L’API Grok Build 0.1 dans CometAPI fournit un accès direct sous l’identifiant de modèle actuel, évitant la dépendance au pseudonyme retiré.
Où pouvez-vous utiliser Grok Build 0.1 ?
Cela signifie que le modèle n’est pas lié à un seul IDE ou point de terminaison de fournisseur. Via CometAPI, les équipes peuvent utiliser le même identifiant grok-build-0.1 dans un flux compatible OpenAI et le comparer avec d’autres modèles de codage sans reconstruire le contrôleur d’agent environnant.
Grok Build 0.1 peut être appelé via xAI ou via CometAPI. Pour CometAPI, envoyez une requête POST authentifiée à api.cometapi.com/v1/chat/completions avec model: "grok-build-0.1" et un tableau messages standard.
curl "https://api.cometapi.com/v1/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $COMETAPI_KEY" \
-d '{
"model": "grok-build-0.1",
"messages": [
{
"role": "user",
"content": "Find the bug in this repository and propose a minimal fix."
}
]
}'
Quand faut-il utiliser Grok Build 0.1 ?
Agents de codage pour IDE
La combinaison spécialisation en codage et faible prix par jeton convient aux workflows interactifs où un agent lit, modifie et valide le code de manière répétée.
Débogage automatisé
Les agents peuvent inspecter une erreur, rechercher les fichiers pertinents, générer un correctif, exécuter des tests et affiner la correction.
Développement web et UI
L’entrée image ouvre la voie à des workflows pilotés par captures d’écran et références de design en parallèle du code source.
Agents logiciels basés sur MCP
L’appel de fonctions et les flux orientés MCP conviennent aux assistants qui ont besoin d’un accès contrôlé à des systèmes de développement externes.
CI et automatisation d’ingénierie
Des workflows sans interface peuvent prendre en charge le tri de bugs, les réparations automatisées, la génération de tests, le refactoring, les migrations et la préparation de pull requests.
Grok Build 0.1 est-il toujours pertinent en 2026 ?
Oui, mais son rôle est spécialisé plutôt que « le modèle le plus récent d’xAI ». Sa valeur réside dans la combinaison de spécialisation en codage, d’une fenêtre de contexte de 256K, du raisonnement, de l’appel d’outils, des sorties structurées, de l’entrée image et de prix standard relativement bas.
Il est le plus convaincant lorsque les équipes ont besoin d’un modèle réactif pour des boucles d’agents logiciels répétées et peuvent l’évaluer sur leurs propres dépôts, tests, objectifs de latence et coûts d’échec.
Conclusion
Grok Build 0.1 est un modèle focalisé sur les agents de codage plutôt qu’un modèle de pointe universel. Ses spécifications et sa tarification officielles le rendent attractif pour le travail à fort volume sur dépôts, mais la conception de l’agent environnant détermine si cet avantage se maintient en production.
Avant de l’adopter, exécutez une évaluation représentative qui mesure l’achèvement des tâches, le temps de correction humaine, le nombre d’appels d’outils, l’utilisation des jetons, le taux de réussite des tests et l’exposition au contexte long. Choisissez-le lorsque l’ensemble du workflow — pas seulement le benchmark ou le prix du jeton — surpasse les alternatives.