Grok 4.20 : le modèle rapide et orienté outils de xAI, expliqué

Grok 4.20 est le modèle de langage haute performance de xAI, conçu pour la vitesse et l'appel d'outils agentique, avec une fenêtre de contexte d'1 million de tokens et ce que xAI présente comme le taux d'hallucination le plus bas du marché. Si vous avez vu ce nom et voulez savoir ce que c'est réellement, dans quoi il excelle, ce qu'il coûte, et le moyen le plus rapide de l'essayer sans toucher à une API, ce guide expose les spécifications vérifiées et vous montre comment le mettre au travail dans un navigateur.

La réponse courte

Grok 4.20 est un modèle de xAI positionné autour de trois axes : des réponses rapides, un appel d'outils agentique solide, et la précision (xAI le décrit comme ayant « le taux d'hallucination le plus bas du marché avec une adhérence stricte aux prompts »). Il accepte du texte et des images en entrée, produit du texte en sortie, prend en charge l'appel de fonctions, les sorties structurées et le raisonnement, et dispose d'une très large fenêtre de contexte de 1 000 000 de tokens. En termes simples : il est optimisé pour être un moteur fiable et rapide pour les agents qui appellent des outils et suivent les instructions avec précision.

Spécifications de Grok 4.20 en un coup d'œil

Grok 4.20 en un coup d'œil — un modèle rapide, à grand contexte, optimisé pour l'appel d'outils agentique.

Dans quoi Grok 4.20 excelle

La fiche technique pointe vers un profil clair. Grok 4.20 est conçu pour être le moteur d'un agent, et trois traits se démarquent :

• L'appel d'outils agentique. Un appel de fonctions solide et fiable est ce qui permet à un modèle d'agir — choisir un outil, l'appeler avec les bons arguments, utiliser le résultat. xAI ouvre sa description de Grok 4.20 avec ce point, ce qui indique qu'il est optimisé pour les agents utilisateurs d'outils, pas seulement pour le chat.
• La vitesse. Une « vitesse leader du secteur » compte énormément dans les boucles d'agents, où un modèle peut être appelé de nombreuses fois de suite ; des réponses plus rapides à chaque étape s'accumulent pour donner un agent bien plus réactif.
• La précision et l'adhérence aux prompts. Un faible taux d'hallucination et une « adhérence stricte aux prompts » sont exactement les traits qui rendent un agent fiable au fil d'une tâche longue et multi-étapes — un modèle qui dérive ou invente des faits est un handicap quand il agit, pas seulement quand il répond.

Ajoutez la fenêtre de contexte d'1 million de tokens, et Grok 4.20 peut garder en vue une grande quantité de matériel à la fois — une grande base de code, un long ensemble de documents, ou un historique d'agent étendu — sans perdre le fil.

Ce que coûte Grok 4.20

La tarification est basée sur l'usage, par million de tokens (selon la documentation des modèles de xAI) : 1,25 $ pour l'entrée, 0,20 $ pour l'entrée en cache, et 2,50 $ pour la sortie. Le tarif d'entrée en cache mérite d'être noté — si votre charge de travail renvoie beaucoup le même contexte (courant dans les boucles d'agents et les sessions longues), la mise en cache peut réduire considérablement le coût d'entrée. Comme toujours avec un usage agentique, le chiffre qui détermine réellement votre facture est le nombre de tokens par tâche, car un agent utilisateur d'outils peut consommer bien plus qu'un simple échange de chat.

Comment Grok 4.20 se compare

On ne choisit pas un modèle isolément. Le cas de Grok 4.20 repose sur la vitesse + un grand contexte + un appel d'outils fiable, ce qui le place dans la conversation avec d'autres modèles de pointe optimisés pour le travail agentique :

Il n'y a pas de gagnant universel — le leadership des modèles évolue constamment, et le test honnête consiste à faire passer votre propre tâche à travers plusieurs modèles. L'argument distinctif de Grok 4.20 est la combinaison de vitesse et d'un très faible taux d'hallucination, ce qui est particulièrement séduisant quand les erreurs d'un agent coûtent cher.

Pourquoi la vitesse s'accumule dans une boucle d'agent

La vitesse ressemble à un bonus agréable jusqu'à ce que vous observiez un agent au travail. Un chatbot appelle le modèle une fois par message, donc une différence d'une demi-seconde se remarque à peine. Un agent appelle le modèle de façon répétée — raisonner, agir, observer, recommencer — souvent des dizaines de fois pour une seule tâche. À dix ou vingt appels de modèle par tâche, un modèle sensiblement plus rapide par appel transforme une exécution d'agent de deux minutes en une exécution de quarante secondes. C'est la différence entre un agent que l'on attend et un agent qui semble réactif. Le fait que xAI mette en avant la « vitesse leader du secteur » de Grok 4.20 n'est pas une métrique de vanité ; pour un usage agentique, c'est l'un des traits que l'on ressent le plus directement, car la boucle le multiplie.

La fenêtre de contexte d'1 million de tokens en pratique

Une fenêtre de contexte de 1 000 000 de tokens est assez grande pour changer la façon dont vous utilisez le modèle. Vous pouvez y déposer une base de code entière de taille moyenne, un long ensemble de documents, ou un historique d'agent profond, et tout avoir disponible en même temps — sans découpage agressif, sans re-récupération constante. Pour le travail agentique, cela signifie que le modèle peut garder l'état complet de la tâche en vue tout au long d'une longue exécution plutôt que d'oublier les étapes précédentes. La mise en garde (traitée plus bas) est qu'une grande fenêtre n'est pas une licence pour la remplir : chaque token coûte toujours de l'argent et rivalise pour l'attention du modèle, donc l'ingénierie du contexte — placer les bonnes choses dans la fenêtre — compte même quand la fenêtre est immense. Mais disposer de cette marge élimine toute une catégorie d'échecs du type « il a perdu le fil de ce qu'il faisait ».

Un flux de travail réaliste avec Grok 4.20

Imaginez lui confier : « Parcours cette spécification d'API de 600 pages et notre base de code, trouve chaque point de terminaison que nous appelons et qui est maintenant obsolète, et liste les remplacements. » Le profil de Grok 4.20 correspond parfaitement à la tâche : la fenêtre d'1M de tokens lui permet de garder en vue de grandes portions de la spécification et du code à la fois ; son appel d'outils lui permet de rechercher dans les fichiers et de vérifier les références ; son réglage à faible hallucination et à adhérence stricte signifie que la liste qu'il retourne a plus de chances d'être réellement composée de points de terminaison obsolètes, et non d'inventions plausibles — ce qui compte énormément quand le résultat est une liste de tâches sur laquelle quelqu'un va agir. Le même modèle, exécuté dans une boucle d'agent avec des outils de fichiers, transforme une journée fastidieuse de recherche par grep en une seule tâche déléguée.

Mises en garde à connaître

Un point de vue équilibré avant de vous engager :

• Le positionnement du fournisseur n'est pas un benchmark indépendant. « Le taux d'hallucination le plus bas du marché » est une affirmation de xAI ; considérez-la comme un signal de ce pour quoi le modèle est optimisé, et vérifiez-la sur vos propres prompts.
• Un grand contexte n'est pas gratuit. Une fenêtre d'1M de tokens est puissante, mais la remplir entièrement coûte des tokens et peut quand même souffrir de limites d'attention — une bonne ingénierie du contexte reste importante.
• La capacité a besoin d'un harnais. La force d'appel d'outils de Grok 4.20 ne se manifeste que lorsqu'il est enveloppé dans une boucle d'agent avec de vrais outils et un bac à sable. Le modèle brut est un moteur ; il lui faut un châssis pour rouler.

Comment utiliser Grok 4.20 sans clé API

Vous pouvez appeler Grok 4.20 directement via l'API de xAI (avec des identifiants de modèle comme grok-4.20-reasoning), ce qui est la bonne voie si vous êtes un développeur qui l'intègre dans votre propre pile technique. Mais si vous voulez simplement l'utiliser — sans clés API, sans configuration de facturation, sans code — le moyen le plus rapide est Happycapy. Grok 4.20 est l'un des plus de 150 modèles disponibles sur Happycapy, un ordinateur agent-natif qui s'exécute dans votre navigateur : vous choisissez Grok 4.20, décrivez une tâche, et il s'exécute dans un bac à sable cloud sécurisé avec les outils et la boucle d'agent déjà configurés.

Deux voies vers Grok 4.20 — l'API brute, ou une plateforme navigateur sans configuration.

Cette association joue directement sur les forces de Grok 4.20. Son point fort est l'appel d'outils agentique et la vitesse — et une plateforme d'agents est exactement l'endroit où ces qualités brillent, car le modèle dispose de vrais outils à appeler et d'une boucle pour les exécuter. Vous pouvez aussi exploiter son profil à faible hallucination et à adhérence stricte sur un travail réel en plusieurs étapes, l'observer sur un bureau visuel, et intervenir quand vous le souhaitez. Et comme Happycapy héberge de nombreux modèles, vous pouvez exécuter la même tâche sur Grok 4.20 et sur Claude ou un modèle ouvert pour voir lequel vous préférez — sans comptes supplémentaires.

Commencez gratuitement sur happycapy.ai, choisissez Grok 4.20, et confiez-lui une vraie tâche — c'est le moyen le plus rapide de juger vous-même de la vitesse et de la précision, sans aucune configuration.

Tirer le meilleur parti de Grok 4.20

Quelques notes pratiques pour bien l'utiliser :

• Misez sur l'entrée en cache pour les boucles. Si votre agent renvoie un prompt système stable ou un ensemble de documents à chaque étape, le tarif réduit d'entrée en cache (0,20 $ contre 1,25 $ par million de tokens) rend les sessions longues bien moins chères — structurez votre contexte pour que la partie stable soit mise en cache.
• Utilisez la grande fenêtre avec discernement. Une fenêtre d'1M de tokens invite à tout y déverser ; résistez à cette tentation. Placez le matériel véritablement pertinent en vue et résumez le reste, afin de ne payer que pour les tokens qui méritent leur place.
• Orientez-le vers un travail riche en outils. Les forces de Grok 4.20 — un appel de fonctions rapide et fiable et une adhérence stricte — sont les plus rentables sur des tâches multi-étapes utilisant des outils, pas sur des questions isolées. Donnez-lui des tâches où il a des outils à appeler.
• Vérifiez vous-même l'affirmation sur la précision. « Taux d'hallucination le plus bas » est le positionnement de xAI ; si la précision est critique pour votre mission, effectuez vos propres vérifications ponctuelles avant de lui faire confiance pour agir sans surveillance.
• Épinglez un identifiant pour la stabilité. Ciblez un identifiant de modèle spécifique quand vous avez besoin d'un comportement cohérent dans le temps, plutôt que de vous fier à un alias flottant susceptible de changer à mesure que le modèle est mis à jour — la même discipline de reproductibilité que vous appliqueriez à toute dépendance de production.

Questions fréquentes

Q : Qu'est-ce que Grok 4.20 ?

C'est le modèle de langage haute performance de xAI, optimisé pour la vitesse et l'appel d'outils agentique, avec une fenêtre de contexte de 1 000 000 de tokens, une entrée texte-et-image, l'appel de fonctions, les sorties structurées et le raisonnement. xAI le positionne comme ayant le taux d'hallucination le plus bas du marché avec une adhérence stricte aux prompts.

Q : Quelle est la fenêtre de contexte de Grok 4.20 ?

1 000 000 de tokens — assez large pour garder en vue simultanément une base de code conséquente, un long ensemble de documents, ou un historique d'agent étendu.

Q : Combien coûte Grok 4.20 ?

Par million de tokens : 1,25 $ pour l'entrée, 0,20 $ pour l'entrée en cache, et 2,50 $ pour la sortie. Le tarif réduit d'entrée en cache aide quand votre charge de travail renvoie beaucoup le même contexte, ce qui est fréquent dans les boucles d'agents.

Q : Grok 4.20 est-il adapté aux agents IA ?

Oui — c'est exactement ce pour quoi il est présenté. Un appel de fonctions solide, la vitesse et un faible taux d'hallucination sont les traits qui font d'un modèle un moteur fiable pour des agents multi-étapes utilisateurs d'outils.

Q : Comment puis-je utiliser Grok 4.20 sans coder ?

Exécutez-le via une plateforme gérée comme Happycapy, où Grok 4.20 est l'un des plus de 150 modèles disponibles dans le navigateur. Vous le choisissez et lui donnez une tâche — sans clé API, sans palier de facturation, sans scripts.

Q : Quel identifiant de modèle et quelles régions Grok 4.20 utilise-t-il ?

Selon la documentation des modèles de xAI, l'identifiant de modèle sous-jacent est grok-4.20-0309-reasoning, avec des alias plus conviviaux tels que grok-4.20 et grok-4.20-reasoning. Via l'API, il est proposé dans plusieurs régions, notamment us-east-1, eu-west-1 et us-west-2.

Q : Grok 4.20 est-il multimodal ?

Il accepte du texte et des images en entrée et produit du texte en sortie — vous pouvez donc lui donner des images à analyser, mais il génère du texte, pas des images. Pour la génération d'images, il faudrait se tourner vers un modèle d'image dédié.

Q : Que signifie le prix de l'entrée en cache en pratique ?

Lorsque vous renvoyez le même contexte (un prompt système, un long document) au fil des appels, cette entrée répétée est facturée au tarif réduit en cache — 0,20 $ par million de tokens contre 1,25 $ pour une entrée nouvelle. Dans les boucles d'agents qui réutilisent beaucoup le contexte, cela peut réduire considérablement les coûts d'entrée.

Q : Grok 4.20 face à un modèle ouvert comme Kimi K2.6 — lequel devrais-je utiliser ?

Grok 4.20 est un modèle fermé rapide, à faible hallucination, avec une immense fenêtre de contexte ; Kimi K2.6 et MiniMax M2.7 sont des modèles agentiques à poids ouverts, auto-hébergeables. Choisissez selon que vous privilégiez la vitesse/précision hébergée ou le contrôle open source — et testez la même tâche sur chacun, ce qui est facile sur une plateforme qui en héberge plusieurs.

Guides associés

• Claude Haiku 4.5 : le modèle le plus rapide d'Anthropic expliqué
• Kimi K2.6 expliqué : le modèle de codage et d'agent open source de Moonshot
• MiniMax M2.7 : le modèle open source conçu pour les flux de travail agentiques
• Claude Code contre GitHub Copilot : agent autonome ou assistant intégré à l'éditeur ?