What makes Grok-4.20 different from previous Grok models?

Grok-4.20 introduserer et multiagent-resonneringssystem der flere agenter analyserer en prompt samtidig og samarbeider om et endelig svar, noe som forbedrer kompleks resonnering og programmeringsytelse.

How large is the context window in the Grok-4.20 API?

Grok-4.20 støtter opptil et kontekstvindu på 2,000,000 tokens, slik at utviklere kan behandle svært lange dokumenter eller datasett i én enkelt forespørsel.

Can Grok-4.20 handle multimodal inputs such as images or video?

Ja. Grok-4.20 støtter multimodale inndata, inkludert tekst, bilder og video, noe som muliggjør analyse av blandet innhold i én enkelt samtale.

How does Grok-4.20 compare with GPT-5.2 or Gemini models?

Grok-4.20 fokuserer på multiagent-resonnering og svært lange kontekstvinduer, mens GPT-5.2 vektlegger svært nøyaktig resonnering og Gemini-modellene fokuserer på multimodal integrasjon innenfor Google-økosystemet.

Is Grok-4.20 available through an API for developers?

Ja. Grok-4.20 er tilgjengelig via Come API.

What benchmarks show Grok-4.20 performance?

Tidlige rapporter plasserer Grok-4.20 rundt 1505–1535 ELO på LMSYS Arena og viser sterke resultater i virkelige konkurranser, for eksempel Alpha Arena-handelssimuleringer.

Rimelig Grok 4.20 API | text-to-text

Tekniske spesifikasjoner for Grok-4.20

Punkt	Grok-4.20 (offentlige spesifikasjoner)
Modellfamilie	Grok-4-serien
Utvikler	xAI
Utgivelsesstatus	Beta (første utrulling 17. feb. 2026)
Inndatatyper	Tekst, bilde, video
Utdatatyper	Tekstutdata (strukturerte utdata og funksjons-/verktøykall støttes).
Kontekstvindu	Opptil 2,000,000 tokens
Arkitektur	Samarbeidsbasert resonnering med flere agenter
Verktøystøtte	Funksjonskall, strukturerte utdata
Resonnering	Innebygde resonnementsevner
Treningsinfrastruktur	Colossus supercluster (~200,000 GPUs)
Modellvarianter	grok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

Hva er Grok-4.20

Grok-4.20 er den nyeste eksperimentelle utgaven i Grok-4-familien utviklet av xAI. Den fokuserer på agentisk resonnering, håndtering av ekstremt lange kontekster og høyhastighetsinferens, med mål om å levere presise svar med lavere hallusinasjonsrate enn tidligere Grok-modeller.

I motsetning til tidligere Grok-modeller som brukte enkeltmodell-inferens, introduserer Grok-4.20 fleragentsamarbeid, der flere interne agenter analyserer en forespørsel samtidig og konvergerer til et endelig svar. Denne arkitekturen er utformet for å forbedre ytelsen på kompleks resonnering, koding og forskning.

Hovedfunksjoner i Grok-4.20

Ekstra langt kontekstvindu (2M tokens): Gjør det mulig å behandle hele bøker, store datasett eller lange kode-repositorier i én forespørsel.
Arkitektur for fleragentsresonnering: Opptil fire interne agenter kan analysere en forespørsel parallelt og diskutere løsninger før de produserer et endelig svar.
Agentisk verktøykalling og strukturerte utdata: Støtter funksjonskall og strukturerte svar for integrasjon med applikasjoner og automatiserte arbeidsflyter.
Multimodal forståelse: Godtar inndata av tekst, bilde og video i samme modell-pipeline.
Rask inferens med fokus på lav hallusinasjon: xAI posisjonerer modellen som optimalisert for sannferdige svar og sterk etterlevelse av forespørsler.

Benchmark-ytelse for Grok-4.20

Public benchmark data is still limited during beta, but early reports indicate:

Benchmark	Resultat / status
LMSYS Chatbot Arena	Estimert ELO ~1505–1535
ForecastBench	Rangert som nr. 2 i tidlige tester
Alpha Arena trading challenge	Oppnådde +34.59% avkastning

Disse tallene antyder at Grok-4.20 konkurrerer med banebrytende modeller i reelle resonnerings- og agentdrevne oppgaver snarere enn enkle benchmark-spørsmål.

Grok-4.20 Beta vs andre banebrytende modeller

Modell	Utvikler	Kontekstvindu	Nøkkelstyrke
Grok-4.20	xAI	2M tokens	Fleragentsresonnering
GPT-5.2	OpenAI	~400K tokens	Avansert resonnering + koding
Gemini 3 Pro	Google	~1M tokens	multimodal og Google-økosystem
Claude 4 Opus	Anthropic	~200K+ tokens	pålitelig resonnering

Viktige forskjeller

Grok-4.20 vektlegger fleragentsamarbeid for resonneringsoppgaver.
Den tilbyr et av de største kontekstvinduene i produksjons-LLM-er (2M tokens).
Konkurrerende modeller kan overgå Grok på enkelte områder, som strukturert resonnering eller kreativ skriving, avhengig av evalueringsoppgaver.

Representative bruksområder

Forskningsanalyse med lang kontekst
Behandle store dokumenter, juridisk materiale eller akademisk forskning.
Agentbaserte automasjonssystemer
Bygg flertrinns arbeidsflyter der modellen planlegger og utfører oppgaver.
Avansert koding og simuleringer
Løs ingeniørproblemer eller simuler systemer med lange resonnementskjeder.
Dataanalyse og dashbordautomatisering
Spor og analyser flere datastrømmer parallelt.
Multimodal kunnskapsprosessering
Tolk bilder, videorammer og tekst i en samlet resonnementprosess.

Slik får du tilgang til og bruker Grok 4.2 API

Trinn 1: Registrer deg for API-nøkkel

Logg inn på cometapi.com. Hvis du ikke er bruker ennå, registrer deg først. Logg inn på CometAPI console. Hent tilgangslegitimasjonen API-nøkkel for grensesnittet. Klikk “Add Token” ved API-token i det personlige senteret, hent token-nøkkelen: sk-xxxxx og send inn.

Trinn 2: Send forespørsler til `Grok 4.2` API

Velg endepunktet “grok-4.20-0309-reasoning” for å sende API-forespørselen og angi forespørselsteksten. Forespørselsmetode og forespørselstekst hentes fra API-dokumentasjonen på nettstedet vårt. Nettstedet vårt tilbyr også Apifox-test for bekvemmelighet. Erstatt <YOUR_API_KEY> med din faktiske CometAPI-nøkkel fra kontoen din. Hvor du kaller det: [Chat]-format.

Sett inn spørsmålet eller forespørselen din i innholdsfeltet—det er dette modellen vil svare på. Behandle API-responsen for å få det genererte svaret.

Trinn 3: Hent og verifiser resultater

Behandle API-responsen for å få det genererte svaret. Etter behandlingen svarer API-et med oppgavestatus og utdata.

Priser for Grok 4.20

Utforsk konkurransedyktige priser for Grok 4.20, designet for å passe ulike budsjetter og bruksbehov. Våre fleksible planer sikrer at du bare betaler for det du bruker, noe som gjør det enkelt å skalere etter hvert som kravene dine vokser. Oppdag hvordan Grok 4.20 kan forbedre prosjektene dine samtidig som kostnadene holdes håndterbare.

Komet-pris (USD / M Tokens)	Offisiell pris (USD / M Tokens)	Rabatt
Inndata:$1/M Utdata:$2/M	Inndata:$1.25/M Utdata:$2.5/M	-20%

Eksempelkode og API for Grok 4.20

Få tilgang til omfattende eksempelkode og API-ressurser for Grok 4.20 for å effektivisere integreringsprosessen din. Vår detaljerte dokumentasjon gir trinn-for-trinn-veiledning som hjelper deg med å utnytte det fulle potensialet til Grok 4.20 i prosjektene dine.

Python
JavaScript
Curl

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))

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));

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

Versjoner av Grok 4.20

Grunnen til at Grok 4.20 har flere øyeblikksbilder kan inkludere potensielle faktorer som variasjoner i utdata etter oppdateringer som krever eldre øyeblikksbilder for konsistens, å gi utviklere en overgangsperiode for tilpasning og migrering, og ulike øyeblikksbilder som tilsvarer globale eller regionale endepunkter for å optimalisere brukeropplevelsen. For detaljerte forskjeller mellom versjoner, vennligst se den offisielle dokumentasjonen.

Modell-ID	beskrivelse	Tilgjengelighet	Forespørsel
grok-4.20-multi-agent-beta-0309	Multi-agent-variant tilpasset sanntids orkestrering av agenter og kall til verktøy (nyttig for dyptgående forskningsarbeidsflyter der flere underagenter utfører websøk, kjøring av kode og kritisk vurdering).	✅	kall i responsformat.
grok-4.20-0309-reasoning	Resonneringsoptimalisert variant: prioriterer dypere «chain-of-thought»-stil resonnement og høyere benchmark-resultater på resonnementstunge tester; høyere latens/kostnad per token forventes sammenlignet med varianter uten resonnement.	✅	kall i chat-format og i responsformat.
grok-4.20-0309-non-reasoning	Variant med lavere latens / lavere kostnad for høy-gjennomstrømmingsoppgaver der deterministiske, korte svar eller strømmende utdata er prioritert; avveininger inkluderer lavere resultater på resonnement-benchmarker.	✅	kall i responsformat.