Claude Opus 5 is now live on CometAPI →
X

Grok 4.20

Indtast:$1/M
Output:$2/M
Kontekst:2,000,000
Udgivet:Mar 11, 2026

Grok 4.20-udgivelsen introducerer en multiagent-arkitektur (flere specialiserede agenter, der koordineres i realtid), udvidede konteksttilstande samt målrettede forbedringer af evnen til at følge instruktioner, reduktion af hallucinationer og strukturerede og værktøjsunderstøttede uddata.

Ny
Kommersiel brug

Playground for Grok 4.20

Udforsk Grok 4.20's Playground — et interaktivt miljø til at teste modeller og køre forespørgsler i realtid. Prøv prompts, juster parametre og iterer øjeblikkeligt for at fremskynde udvikling og validere use cases.

Tekniske specifikationer for Grok-4.20

PunktGrok-4.20 (offentlige specifikationer)
ModelfamilieGrok-4-serien
UdviklerxAI
UdgivelsesstatusBeta (første udrulning 17. feb. 2026)
InputtyperTekst, billede, video
OutputtyperTekstuddata (strukturerede output og funktions-/værktøjskald understøttes).
KontekstvindueOp til 2,000,000 tokens
ArkitekturSamarbejdende multi-agent-ræsonnering
VærktøjsunderstøttelseFunktionskald, strukturerede output
RæsonnementIndbyggede ræsonneringsevner
TræningsinfrastrukturColossus-superklynge (~200,000 GPU'er)
Modelvariantergrok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

Hvad er Grok-4.20

Grok-4.20 er den seneste eksperimentelle udgave i Grok-4-familien udviklet af xAI. Den fokuserer på agent-baseret ræsonnering, håndtering af ekstremt lange kontekster og højhastighedsinferens med det mål at levere præcise svar med lavere hallucinationsrate end tidligere Grok-modeller.

I modsætning til tidligere Grok-modeller, der brugte inferens med én model, introducerer Grok-4.20 multi-agent-samarbejde, hvor flere interne agenter analyserer en prompt samtidig og konvergerer mod et endeligt svar. Denne arkitektur er designet til at forbedre ydeevnen på komplekse ræsonnerings-, kode- og forskningstasks.

Hovedfunktioner i Grok-4.20

  • Ultralangt kontekstvindue (2M tokens): Muliggør behandling af hele bøger, store datasæt eller lange koderepositorier i én prompt.
  • Multi-agent-ræsonneringsarkitektur: Op til fire interne agenter kan analysere en prompt parallelt og debattere løsninger, før de producerer et endeligt svar.
  • Agent-baserede værktøjskald og strukturerede output: Understøtter funktionskald og strukturerede svar til integration med applikationer og automatiserede arbejdsgange.
  • Multimodal forståelse: Accepterer tekst-, billede- og video-input i den samme modelpipeline.
  • Hurtig inferens med fokus på lav hallucinationsrate: xAI positionerer modellen som optimeret til sande svar og stærk efterlevelse af prompts.

Benchmark-ydelse for Grok-4.20

Offentlige benchmark-data er stadig begrænsede under beta, men tidlige rapporter indikerer:

BenchmarkResultat / status
LMSYS Chatbot ArenaAnslået ELO ~1505–1535
ForecastBenchRangeret som nr. 2 i tidlige tests
Alpha Arena trading challengeOpnåede +34.59% afkast

Disse tal antyder, at Grok-4.20 konkurrerer med frontmodeller i virkelige ræsonnerings- og agent-drevne opgaver frem for simple benchmark-spørgsmål.

Grok-4.20 Beta vs andre førende modeller

ModelUdviklerKontekstvindueNøglestyrke
Grok-4.20xAI2M tokensMulti-agent-ræsonnering
GPT-5.2OpenAI~400K tokensAvanceret ræsonnering + kodning
Gemini 3 ProGoogle~1M tokensmultimodal og Google-økosystem
Claude 4 OpusAnthropic~200K+ tokenspålidelig ræsonnering

Væsentlige forskelle

  • Grok-4.20 lægger vægt på multi-agent-samarbejde til ræsonneringsopgaver.
  • Den tilbyder et af de største kontekstvinduer i produktions-LLM'er (2M tokens).
  • Konkurrerende modeller kan overgå Grok på visse områder som struktureret ræsonnering eller kreativ skrivning afhængigt af evalueringstask.

Repræsentative anvendelsestilfælde

  1. Langkontekst-forskningsanalyse
    Behandling af store dokumenter, juridisk materiale eller akademisk forskning.
  2. Agentiske automationssystemer
    Opbyg multi-trins arbejdsgange, hvor modellen planlægger og udfører opgaver.
  3. Avanceret kodning og simulationer
    Løs ingeniørproblemer eller simuler systemer med lange ræsonneringskæder.
  4. Dataanalyse og dashboard-automatisering
    Spor og analyser flere datastrømme parallelt.
  5. Multimodal vidensbehandling
    Fortolk billeder, videorammer og tekst i en samlet ræsonneringsproces.

Sådan får du adgang til og bruger Grok 4.2 API

Trin 1: Registrér dig for en API-nøgle

Log ind på cometapi.com. Hvis du ikke er vores bruger endnu, skal du registrere dig først. Log ind på din CometAPI-konsol. Hent interfacets adgangslegitimations-API-nøgle. Klik på “Add Token” ved API-token i det personlige center, få token-nøglen: sk-xxxxx og indsend.

Trin 2: Send forespørgsler til Grok 4.2 API

Vælg “grok-4.20-0309-reasoning”-endepunktet for at sende API-forespørgslen og angiv request body. Anmodningsmetode og request body hentes fra vores websites API-dokumentation. Vores website tilbyder også Apifox-test for din bekvemmelighed. Erstat <YOUR_API_KEY> med din faktiske CometAPI-nøgle fra din konto. Hvor den kaldes: [Chat]-format.

Indsæt dit spørgsmål eller din anmodning i content-feltet—det er dette, modellen vil svare på. Behandl API-svaret for at få det genererede svar.

Trin 3: Hent og verificér resultater

Behandl API-svaret for at få det genererede svar. Efter behandlingen svarer API'et med opgavestatus og outputdata.

FAQ

Priser for Grok 4.20

Udforsk konkurrencedygtige priser for Grok 4.20, designet til at passe til forskellige budgetter og brugsbehov. Vores fleksible planer sikrer, at du kun betaler for det, du bruger, hvilket gør det nemt at skalere, efterhånden som dine krav vokser. Opdag hvordan Grok 4.20 kan forbedre dine projekter, mens omkostningerne holdes håndterbare.

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

Eksempelkode og API til Grok 4.20

Få adgang til omfattende eksempelkode og API-ressourcer for Grok 4.20 for at strømline din integrationsproces. Vores detaljerede dokumentation giver trin-for-trin vejledning, der hjælper dig med at udnytte det fulde potentiale af Grok 4.20 i dine projekter.

#!/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));

Versioner af Grok 4.20

Årsagen til, at Grok 4.20 har flere øjebliksbilleder kan omfatte potentielle faktorer såsom variationer i output efter opdateringer, der kræver ældre øjebliksbilleder for konsistens, at give udviklere en overgangsperiode til tilpasning og migration, og at forskellige øjebliksbilleder svarer til globale eller regionale slutpunkter for at optimere brugeroplevelsen. For detaljerede forskelle mellem versioner, henvises der til den officielle dokumentation.

Model-idbeskrivelseTilgængelighedAnmodning
grok-4.20-multi-agent-beta-0309Multi-agent-variant optimeret til orkestrering af agenter i realtid og kald til værktøjer (nyttig til dybdegående forskningsarbejdsgange, hvor flere underagenter udfører websøgninger, kodeeksekvering og kritik).✅response-format-kald.
grok-4.20-0309-reasoningRæsonnement-optimeret variant: prioriterer dybere chain-of-thought-stil ræsonnement og højere benchmark-scorer på ræsonnementstunge test; højere latenstid/omkostning pr. token forventes i forhold til ikke-ræsonnerende varianter.✅chat-format-kald og response-format-kald.
grok-4.20-0309-non-reasoningVariant med lavere latenstid / lavere omkostninger til opgaver med høj gennemløb, hvor deterministiske, korte svar eller streaming-output er prioritet; kompromiser omfatter lavere benchmark-scorer for ræsonnement.✅chat-format-kald og response-format-kald.