ModellerPriserVirksomhed
500+ AI Model API, Alt I Én API. Kun I CometAPI
Modeller API
Udvikler
Hurtig StartDokumentationAPI Dashboard
Virksomhed
Om osVirksomhed
Ressourcer
AI-modellerBlogÆndringslogSupport
ServicevilkårPrivatlivspolitik
© 2026 CometAPI · All rights reserved
Home/Models/xAI/Grok 4.20
X

Grok 4.20

Indtast:$1.6/M
Output:$4.8/M
Kontekst:2,000,000
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
Oversigt
Funktioner
Priser
API
Versioner

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

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.

Funktioner til Grok 4.20

Udforsk de vigtigste funktioner i Grok 4.20, designet til at forbedre ydeevne og brugervenlighed. Opdag hvordan disse muligheder kan gavne dine projekter og forbedre brugeroplevelsen.

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.6/M
Output:$4.8/M
Indtast:$2/M
Output:$6/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.
POST
/v1/chat/completions
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-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.

Flere modeller

C

Claude Opus 4.7

Indtast:$3/M
Output:$15/M
Den mest intelligente model til agenter og kodning
A

Claude Sonnet 4.6

Indtast:$2.4/M
Output:$12/M
Claude Sonnet 4.6 er vores hidtil mest kapable Sonnet-model. Det er en fuld opgradering af modellens færdigheder på tværs af kodning, computerbrug, langkontekstlig ræsonnering, agentplanlægning, vidensarbejde og design. Sonnet 4.6 har også et kontekstvindue på 1M tokens i beta.
O

GPT 5.5 Pro

Indtast:$24/M
Output:$144/M
En avanceret model udviklet til ekstremt kompleks logik og professionelle krav, der repræsenterer den højeste standard for dybdegående ræsonnering og præcise analytiske evner.
O

GPT 5.5

Indtast:$4/M
Output:$24/M
En multimodal flagskibsmodel af næste generation, der balancerer mellem enestående ydeevne og effektiv respons, dedikeret til at levere omfattende og stabile AI-tjenester til generelle formål.
O

GPT Image 2 ALL

Per anmodning:$0.04
GPT Image 2 er OpenAIs topmoderne billedgenereringsmodel til hurtig billedgenerering og -redigering i høj kvalitet. Den understøtter fleksible billedstørrelser og billedinput i høj kvalitet.
O

GPT 5.5 ALL

Indtast:$4/M
Output:$24/M
GPT-5.5 udmærker sig inden for kodning, online research, dataanalyse og operationer på tværs af værktøjer. Modellen øger ikke blot sin autonomi i håndteringen af komplekse flertrinsopgaver, men forbedrer også markant ræsonneringsevner og effektivitet i udførelsen, samtidig med at den bevarer samme latens som sin forgænger, hvilket markerer et vigtigt skridt mod automatiseret kontorautomatisering inden for AI.

Relaterede blogs

Cursor Composer vs Windsurf vs GitHub Copilot: Priser & hvad du faktisk får
Apr 20, 2026
copilot
composer-2
windsurf

Cursor Composer vs Windsurf vs GitHub Copilot: Priser & hvad du faktisk får

Hvis du vil have det bedste autonome output, vinder Cursor som regel. Hvis du vil have den mest sømløse guidede redigeringsoplevelse, er Windsurf ofte det mest behagelige. Hvis du vil have den bedste GitHub-native arbejdsgang pr. dollar, er Copilot den mest praktiske. Den rangering er en slutning baseret på de nuværende produktdesigns, prissætning og agentmodeller, som hver leverandør har offentliggjort.
Hvad er Grok 4.2: Funktioner, arkitektur og sammenligninger
Mar 12, 2026
grok-4-2

Hvad er Grok 4.2: Funktioner, arkitektur og sammenligninger

Grok 4.2 er xAI's flagskib i offentlig beta i Grok 4-familien: en multi-agent, værktøjsunderstøttet generativ model med brancheførende gennemløbshastighed, et gigantisk kontekstvindue i agenttilstand på 2,000,000 tokens og specialiserede API-varianter såsom grok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning og grok-4.20-beta-0309-non-reasoning. Den er optimeret til hurtige, agent-baserede arbejdsgange (real-time X-data / værktøjskald), er tilgængelig på web, iOS/Android og tidlige API-kanaler, fx CometAPI, og er målrettet brugere, der har brug for hurtige, live-data-understøttede assistenter frem for den mest dybdegående, langformede ræsonnering.
Sådan bruger du Grok 4.2 API i 2026
Mar 12, 2026
grok-4-2

Sådan bruger du Grok 4.2 API i 2026

Grok 4.2 er xAIs nyeste multiagent‑ræsonnementsmodel, der kombinerer fire samarbejdende agenter og nye agent‑baserede funktioner til værktøjskald for at levere markant hurtigere inferens med færre hallucinationer til enterprise‑workloads. For at kalde den i dag bruger de fleste udviklere enten (a) de officielle xAI REST/gRPC‑endpoints eller (b) kalder den via en aggregator som CometAPI (ét REST‑endpoint, POST https://api.cometapi.com/v1/responsess), som forenkler nøgler, fakturering og skift mellem flere modeller.
Grok 4.2: Hvad vil det bringe, og hvorfor det er vigtigt for AI i 2026
Jan 18, 2026
grok-4-2

Grok 4.2: Hvad vil det bringe, og hvorfor det er vigtigt for AI i 2026

Grok 4.2, en sofistikeret iteration af Elon Musks flagskibsmodel. I modsætning til sine forgængere er Grok 4.2 kommet via en række "stealth checkpoints"—mystiske modelvarianter, der dukker op på ranglister under kodenavne som *Obsidian, Vortex Shade og Quantum Crow.