What makes Grok-4.20 different from previous Grok models?

Grok-4.20 introducerer et multi-agent ræsonneringssystem, hvor flere agenter analyserer en prompt samtidig og samarbejder om et endeligt svar, hvilket forbedrer kompleks ræsonnering og kodningsydeevne.

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

Grok-4.20 understøtter op til et 2,000,000-token kontekstvindue, hvilket gør det muligt for udviklere at behandle ekstremt lange dokumenter eller datasæt i en enkelt anmodning.

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

Ja. Grok-4.20 understøtter multimodale input, herunder tekst, billeder og video, hvilket muliggør analyse af blandet indhold i en enkelt samtale.

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

Grok-4.20 fokuserer på multi-agent ræsonnering og meget lange kontekstvinduer, mens GPT-5.2 lægger vægt på ræsonnering med høj nøjagtighed, og Gemini-modeller fokuserer på multimodal integration i Googles økosystem.

Is Grok-4.20 available through an API for developers?

Ja. Grok-4.20 er tilgængelig via Come API.

What benchmarks show Grok-4.20 performance?

Tidlige rapporter placerer Grok-4.20 omkring 1505–1535 ELO på LMSYS Arena samt stærke resultater i konkurrencer i den virkelige verden såsom Alpha Arena-handelsimuleringer.

Overkommelig Grok 4.20 API | text-to-text

Tekniske specifikationer for Grok-4.20

Punkt	Grok-4.20 (offentlige specifikationer)
Modelfamilie	Grok-4-serien
Udvikler	xAI
Udgivelsesstatus	Beta (første udrulning 17. feb. 2026)
Inputtyper	Tekst, billede, video
Outputtyper	Tekstuddata (strukturerede output og funktions-/værktøjskald understøttes).
Kontekstvindue	Op til 2,000,000 tokens
Arkitektur	Samarbejdende multi-agent-ræsonnering
Værktøjsunderstøttelse	Funktionskald, strukturerede output
Ræsonnement	Indbyggede ræsonneringsevner
Træningsinfrastruktur	Colossus-superklynge (~200,000 GPU'er)
Modelvarianter	grok-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:

Benchmark	Resultat / status
LMSYS Chatbot Arena	Anslået ELO ~1505–1535
ForecastBench	Rangeret som nr. 2 i tidlige tests
Alpha Arena trading challenge	Opnå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

Model	Udvikler	Kontekstvindue	Nøglestyrke
Grok-4.20	xAI	2M tokens	Multi-agent-ræsonnering
GPT-5.2	OpenAI	~400K tokens	Avanceret ræsonnering + kodning
Gemini 3 Pro	Google	~1M tokens	multimodal og Google-økosystem
Claude 4 Opus	Anthropic	~200K+ tokens	på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

Langkontekst-forskningsanalyse
Behandling af store dokumenter, juridisk materiale eller akademisk forskning.
Agentiske automationssystemer
Opbyg multi-trins arbejdsgange, hvor modellen planlægger og udfører opgaver.
Avanceret kodning og simulationer
Løs ingeniørproblemer eller simuler systemer med lange ræsonneringskæder.
Dataanalyse og dashboard-automatisering
Spor og analyser flere datastrømme parallelt.
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.

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.

Comet-pris (USD / M Tokens)	Officiel Pris (USD / M Tokens)	Rabat
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.

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

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-id	beskrivelse	Tilgængelighed	Anmodning
grok-4.20-multi-agent-beta-0309	Multi-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-reasoning	Ræ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-reasoning	Variant 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.