Claude Opus 5 is now live on CometAPI →
X

Grok 4.20

Ingresso:$1/M
Uscita:$2/M
Contesto:2,000,000
Rilasciato:Mar 11, 2026

La versione 4.20 di Grok introduce un'architettura multi-agente (più agenti specializzati coordinati in tempo reale), modalità di contesto estese e miglioramenti mirati alla capacità di seguire le istruzioni, alla riduzione delle allucinazioni e agli output strutturati/strumentati.

Nuovo
Uso commerciale

Playground per Grok 4.20

Esplora il Playground di Grok 4.20 — un ambiente interattivo per testare modelli ed eseguire query in tempo reale. Prova prompt, regola parametri e itera istantaneamente per accelerare lo sviluppo e convalidare i casi d'uso.

Specifiche tecniche di Grok-4.20

VoceGrok-4.20 (specifiche pubbliche)
Famiglia del modelloSerie Grok-4
SviluppatorexAI
Stato di rilascioBeta (prima distribuzione 17 feb 2026)
Tipi di inputTesto, Immagine, Video
Tipi di outputOutput testuali (supporto a output strutturati e chiamata di funzioni/strumenti).
Finestra di contestoFino a 2,000,000 token
ArchitetturaRagionamento collaborativo multi-agente
Supporto agli strumentiChiamata di funzioni, output strutturati
RagionamentoCapacità di ragionamento integrate
Infrastruttura di trainingSupercluster Colossus (~200,000 GPUs)
Varianti del modellogrok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

Che cos’è Grok-4.20

Grok-4.20 è l’ultima release sperimentale della famiglia Grok-4 sviluppata da xAI. Si concentra su ragionamento basato su agenti, gestione di contesti estremamente lunghi e inferenza ad alta velocità, con l’obiettivo di fornire risposte precise con un tasso di allucinazioni inferiore rispetto ai modelli Grok precedenti.

A differenza dei precedenti modelli Grok che utilizzavano inferenza a singolo modello, Grok-4.20 introduce la collaborazione multi-agente, in cui più agenti interni analizzano simultaneamente un prompt e convergono su una risposta finale. Questa architettura è progettata per migliorare le prestazioni in compiti di ragionamento complesso, coding e ricerca.

Caratteristiche principali di Grok-4.20

  • Finestra di contesto ultra‑estesa (2M token): consente di elaborare interi libri, grandi dataset o lunghi repository di codice in un unico prompt.
  • Architettura di ragionamento multi‑agente: fino a quattro agenti interni possono analizzare un prompt in parallelo e discutere le soluzioni prima di produrre una risposta finale.
  • Chiamata di strumenti orientata ad agenti e output strutturati: supporta la chiamata di funzioni e risposte strutturate per l’integrazione con applicazioni e workflow automatizzati.
  • Comprensione multimodale: accetta input di testo, immagine e video all’interno della stessa pipeline del modello.
  • Inferenza rapida con focus su basse allucinazioni: xAI presenta il modello come ottimizzato per risposte veritiere e forte aderenza ai prompt.

Prestazioni benchmark di Grok-4.20

I dati di benchmark pubblici sono ancora limitati durante la beta, ma le prime segnalazioni indicano:

BenchmarkRisultato / Stato
LMSYS Chatbot ArenaELO stimato ~1505–1535
ForecastBenchClassificato #2 nei primi test
Alpha Arena trading challengeHa ottenuto +34.59% di rendimento

Questi numeri suggeriscono che Grok-4.20 compete con i modelli d’avanguardia in compiti reali di ragionamento e guidati da agenti, più che in semplici domande da benchmark.

Grok-4.20 Beta vs altri modelli d’avanguardia

ModelloSviluppatoreFinestra di contestoPunto di forza chiave
Grok-4.20xAI2M tokenRagionamento multi‑agente
GPT-5.2OpenAI~400K tokenRagionamento avanzato + programmazione
Gemini 3 ProGoogle~1M tokenMultimodale ed ecosistema Google
Claude 4 OpusAnthropic~200K+ tokenRagionamento affidabile

Differenze chiave

  • Grok-4.20 enfatizza la collaborazione multi‑agente per i compiti di ragionamento.
  • Offre una delle finestre di contesto più grandi tra gli LLM in produzione (2M token).
  • I modelli concorrenti possono superare Grok in alcune aree, come il ragionamento strutturato o la scrittura creativa, a seconda dei task di valutazione.

Casi d’uso rappresentativi

  1. Analisi di ricerca con contesto esteso
    Elaborare grandi documenti, materiale legale o ricerche accademiche.
  2. Sistemi di automazione basati su agenti
    Costruire workflow multi‑step in cui il modello pianifica ed esegue i task.
  3. Programmazione avanzata e simulazioni
    Risolvere problemi di ingegneria o simulare sistemi con lunghe catene di ragionamento.
  4. Analisi dei dati e automazione di dashboard
    Monitorare e analizzare in parallelo più flussi di dati.
  5. Elaborazione multimodale della conoscenza
    Interpretare immagini, frame video e testo in un processo di ragionamento unificato.

Come accedere e utilizzare l’API Grok 4.2

Passaggio 1: Registrarsi per ottenere la chiave API

Accedi a cometapi.com. Se non sei ancora nostro utente, registrati prima. Accedi alla console CometAPI. Ottieni la chiave API di accesso all’interfaccia. Fai clic su “Add Token” nella sezione API token del centro personale, ottieni la chiave token: sk-xxxxx e invia.

Passaggio 2: Inviare richieste all’API Grok 4.2

Seleziona l’endpoint “grok-4.20-0309-reasoning” per inviare la richiesta API e impostare il corpo della richiesta. Il metodo e il corpo della richiesta sono reperibili nella documentazione API del nostro sito. Il nostro sito fornisce anche test Apifox per tua comodità. Sostituisci <YOUR_API_KEY> con la chiave CometAPI effettiva del tuo account. Dove chiamarlo: Chat formato.

Inserisci la tua domanda o richiesta nel campo content—è a questo che il modello risponderà. Elabora la risposta dell’API per ottenere l’output generato.

Passaggio 3: Recuperare e verificare i risultati

Elabora la risposta dell’API per ottenere l’output generato. Dopo l’elaborazione, l’API risponde con lo stato dell’attività e i dati di output.

FAQ

Prezzi per Grok 4.20

Esplora i prezzi competitivi per Grok 4.20, progettato per adattarsi a vari budget e necessità di utilizzo. I nostri piani flessibili garantiscono che paghi solo per quello che usi, rendendo facile scalare man mano che i tuoi requisiti crescono. Scopri come Grok 4.20 può migliorare i tuoi progetti mantenendo i costi gestibili.

ModelComet Price (USD / M Tokens)Official Price (USD / M Tokens)Discount
grok-4.20-0309-reasoning
Ingresso:$1/M
Uscita:$2/M
Ingresso:$1.25/M
Uscita:$2.5/M
-20%

Codice di esempio e API per Grok 4.20

Accedi a codice di esempio completo e risorse API per Grok 4.20 per semplificare il tuo processo di integrazione. La nostra documentazione dettagliata fornisce una guida passo dopo passo, aiutandoti a sfruttare appieno il potenziale di Grok 4.20 nei tuoi progetti.

#!/usr/bin/env bash
# Get your CometAPI key from https://api.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.20-multi-agent-beta-0309",
    "input": [
      {
        "role": "user",
        "content": "Research the latest breakthroughs in quantum computing and summarize the key findings."
      }
    ],
    "tools": [
      {"type": "web_search"},
      {"type": "x_search"}
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s
' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s
' "$response"
fi

cURL Code Example

#!/usr/bin/env bash
# Get your CometAPI key from https://api.cometapi.com/console/token
# Export it as: export COMETAPI_KEY="your-key-here"

response=$(curl --silent --location --request POST "https://api.cometapi.com/v1/responses" \
  --header "Authorization: Bearer $COMETAPI_KEY" \
  --header "Content-Type: application/json" \
  --header "Accept: application/json" \
  --data-raw '{
    "model": "grok-4.20-multi-agent-beta-0309",
    "input": [
      {
        "role": "user",
        "content": "Research the latest breakthroughs in quantum computing and summarize the key findings."
      }
    ],
    "tools": [
      {"type": "web_search"},
      {"type": "x_search"}
    ]
  }')

if command -v jq >/dev/null 2>&1; then
  printf '%s\n' "$response" | jq -r '(
    [
      .output[]?
      | select(.type == "message")
      | .content[]?
      | select(.type == "output_text")
      | .text
    ][0]
  ) // .output_text // .'
else
  printf '%s\n' "$response"
fi

Python Code Example

import os

from openai import OpenAI

# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
BASE_URL = "https://api.cometapi.com/v1"

client = OpenAI(base_url=BASE_URL, api_key=COMETAPI_KEY)
response = client.responses.create(
    model="grok-4.20-multi-agent-beta-0309",
    input=[
        {
            "role": "user",
            "content": "Research the latest breakthroughs in quantum computing and summarize the key findings.",
        }
    ],
    tools=[{"type": "web_search"}, {"type": "x_search"}],
)

print(response.output_text or response.model_dump_json(indent=2))

JavaScript Code Example

import OpenAI from "openai";

// Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
const apiKey = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const baseUrl = "https://api.cometapi.com/v1";

const client = new OpenAI({
  apiKey,
  baseURL: baseUrl,
});

const response = await client.responses.create({
  model: "grok-4.20-multi-agent-beta-0309",
  input: [
    {
      role: "user",
      content: "Research the latest breakthroughs in quantum computing and summarize the key findings.",
    },
  ],
  tools: [{ type: "web_search" }, { type: "x_search" }],
});

console.log(response.output_text ?? JSON.stringify(response.output, null, 2));

Versioni di Grok 4.20

Il motivo per cui Grok 4.20 dispone di più snapshot può includere fattori potenziali come variazioni nell'output dopo aggiornamenti che richiedono snapshot precedenti per coerenza, offrire agli sviluppatori un periodo di transizione per l'adattamento e la migrazione, e diversi snapshot corrispondenti a endpoint globali o regionali per ottimizzare l'esperienza utente. Per le differenze dettagliate tra le versioni, si prega di fare riferimento alla documentazione ufficiale.

ID del modellodescrizioneDisponibilitàRichiesta
grok-4.20-multi-agent-beta-0309Variante multi-agente ottimizzata per l'orchestrazione in tempo reale degli agenti e l'invocazione di strumenti (utile per flussi di lavoro di ricerca approfondita in cui più sotto-agenti effettuano ricerche sul web, eseguono codice e conducono valutazioni critiche).✅chiamate in formato response.
grok-4.20-0309-reasoningVariante ottimizzata per il ragionamento: privilegia un ragionamento più profondo in stile chain-of-thought e punteggi più elevati nei benchmark su test fortemente orientati al ragionamento; è prevista una latenza/costo per token più elevata rispetto alle varianti non orientate al ragionamento.✅chiamata in formato chat e chiamate in formato response.
grok-4.20-0309-non-reasoningVariante a bassa latenza / a costo inferiore per attività ad alto throughput in cui la priorità sono risposte deterministiche e brevi o output in streaming; i compromessi includono punteggi inferiori nei benchmark di ragionamento.✅chiamata in formato chat e chiamate in formato response.