ModellerPriserBedrift
500+ AI-modell API, Alt I Én API. Bare I CometAPI
Modeller API
Utvikler
HurtigstartDokumentasjonAPI Dashbord
Selskap
Om ossBedrift
Ressurser
AI-modellerBloggEndringsloggStøtte
TjenestevilkårPersonvernerklæring
© 2026 CometAPI · All rights reserved
Home/Models/xAI/Grok 4.20
X

Grok 4.20

Inndata:$1.6/M
Utdata:$4.8/M
Kontekst:2,000,000
Grok 4.20-versjonen introduserer en multiagent-arkitektur (flere spesialiserte agenter koordinert i sanntid), utvidede kontekstmoduser og målrettede forbedringer innen etterlevelse av instruksjoner, reduksjon av hallusinasjoner og strukturerte/til verktøy tilpassede utdata.
Ny
Kommersiell bruk
Playground
Oversikt
Funksjoner
Priser
API
Versjoner

Tekniske spesifikasjoner for Grok-4.20

PunktGrok-4.20 (offentlige spesifikasjoner)
ModellfamilieGrok-4-serien
UtviklerxAI
UtgivelsesstatusBeta (første utrulling 17. feb. 2026)
InndatatyperTekst, bilde, video
UtdatatyperTekstutdata (strukturerte utdata og funksjons-/verktøykall støttes).
KontekstvinduOpptil 2,000,000 tokens
ArkitekturSamarbeidsbasert resonnering med flere agenter
VerktøystøtteFunksjonskall, strukturerte utdata
ResonneringInnebygde resonnementsevner
TreningsinfrastrukturColossus supercluster (~200,000 GPUs)
Modellvariantergrok-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:

BenchmarkResultat / status
LMSYS Chatbot ArenaEstimert ELO ~1505–1535
ForecastBenchRangert som nr. 2 i tidlige tester
Alpha Arena trading challengeOppnå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

ModellUtviklerKontekstvinduNøkkelstyrke
Grok-4.20xAI2M tokensFleragentsresonnering
GPT-5.2OpenAI~400K tokensAvansert resonnering + koding
Gemini 3 ProGoogle~1M tokensmultimodal og Google-økosystem
Claude 4 OpusAnthropic~200K+ tokenspå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

  1. Forskningsanalyse med lang kontekst
    Behandle store dokumenter, juridisk materiale eller akademisk forskning.
  2. Agentbaserte automasjonssystemer
    Bygg flertrinns arbeidsflyter der modellen planlegger og utfører oppgaver.
  3. Avansert koding og simuleringer
    Løs ingeniørproblemer eller simuler systemer med lange resonnementskjeder.
  4. Dataanalyse og dashbordautomatisering
    Spor og analyser flere datastrømmer parallelt.
  5. 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.

FAQ

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.

Funksjoner for Grok 4.20

Utforsk nøkkelfunksjonene til Grok 4.20, designet for å forbedre ytelse og brukervennlighet. Oppdag hvordan disse mulighetene kan være til nytte for prosjektene dine og forbedre brukeropplevelsen.

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.6/M
Utdata:$4.8/M
Inndata:$2/M
Utdata:$6/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.
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

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-IDbeskrivelseTilgjengelighetForespørsel
grok-4.20-multi-agent-beta-0309Multi-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-reasoningResonneringsoptimalisert 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-reasoningVariant 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.

Flere modeller

C

Claude Opus 4.7

Inndata:$3/M
Utdata:$15/M
Den mest intelligente modellen for agenter og koding
A

Claude Sonnet 4.6

Inndata:$2.4/M
Utdata:$12/M
Claude Sonnet 4.6 er vår mest kapable Sonnet-modell hittil. Det er en fullstendig oppgradering av modellens ferdigheter innen koding, bruk av datamaskin, resonnering over lange kontekster, agentplanlegging, kunnskapsarbeid og design. Sonnet 4.6 har også et kontekstvindu på 1M token i beta.
O

GPT 5.5 Pro

Inndata:$24/M
Utdata:$144/M
En avansert modell utviklet for ekstremt kompleks logikk og profesjonelle krav, som representerer den høyeste standarden for dyp resonnering og analytisk presisjon.
O

GPT 5.5

Inndata:$4/M
Utdata:$24/M
En multimodal flaggskipsmodell av neste generasjon som balanserer eksepsjonell ytelse med effektiv respons, dedikert til å levere omfattende og stabile KI-tjenester for generelle formål.
O

GPT Image 2 ALL

Per forespørsel:$0.04
GPT Image 2 er OpenAIs toppmoderne bildegenereringsmodell for rask bildegenerering og redigering av høy kvalitet. Den støtter fleksible bildestørrelser og bildeinndata av høy kvalitet.
O

GPT 5.5 ALL

Inndata:$4/M
Utdata:$24/M
GPT-5.5 utmerker seg innen koding, nettbasert informasjonsinnhenting, dataanalyse og operasjoner på tvers av verktøy. Modellen forbedrer ikke bare sin autonomi i håndteringen av komplekse flertrinnsoppgaver, men øker også resonnementsevnen og effektiviteten i utførelsen betydelig, samtidig som den opprettholder samme latenstid som forgjengeren, og markerer et viktig steg mot automatisert kontorautomatisering i KI.

Relaterte blogger

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

Cursor Composer vs Windsurf vs GitHub Copilot: Priser og hva du faktisk får

Hvis du vil ha det beste autonome resultatet, vinner Cursor som regel. Hvis du vil ha den mest smidige veiledede redigeringsopplevelsen, er Windsurf ofte det mest behagelige. Hvis du vil ha den beste GitHub-native arbeidsflyten per dollar, er Copilot det mest praktiske. Den rangeringen er en slutning basert på de nåværende produktdesignene, prissettingen og agentmodellene som hver leverandør har publisert.
Hva er Grok 4.2: Funksjoner, arkitektur og sammenligninger
Mar 12, 2026
grok-4-2

Hva er Grok 4.2: Funksjoner, arkitektur og sammenligninger

Grok 4.2 er xAIs flaggskip i offentlig beta i Grok 4-familien: en multiagent- og verktøyaktivert generativ modell med bransjeledende gjennomstrømning, et enormt 2,000,000-token kontekstvindu i agentmodus, og spesialiserte API-varianter som grok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning og grok-4.20-beta-0309-non-reasoning. Den er optimalisert for raske, agent-baserte arbeidsflyter (sanntids X-data / verktøykall), er tilgjengelig på Web, iOS/Android og tidlige API-kanaler, f.eks. CometAPI, og er rettet mot brukere som trenger raske assistenter med forståelse for sanntidsdata heller enn det aller mest dyptgående, langvarige resonnementet.
Slik bruker du Grok 4.2 API i 2026
Mar 12, 2026
grok-4-2

Slik bruker du Grok 4.2 API i 2026

Grok 4.2 er xAIs nyeste multiagent-resonneringsmodell som kombinerer fire samarbeidende agenter og nye funksjoner for agentdrevne verktøykall for å levere langt raskere inferens med lavere forekomst av hallusinasjoner for bedriftsarbeidslaster. For å gjøre kall i dag foretar de fleste utviklere enten (a) kall til de offisielle xAI REST/gRPC-endepunktene eller (b) kall via en aggregator som CometAPI (ett enkelt REST-endepunkt,post https://api.cometapi.com/v1/responsess) som forenkler nøkler, fakturering og bytte mellom flere modeller.
Grok 4.2: hva vil det bringe, og hvorfor det er viktig for AI i 2026
Jan 18, 2026
grok-4-2

Grok 4.2: hva vil det bringe, og hvorfor det er viktig for AI i 2026

Grok 4.2, en sofistikert iterasjon av Elon Musks flaggskipmodell. I motsetning til forgjengerne har Grok 4.2 ankommet gjennom en serie med «stealth checkpoints» – mystiske modellvarianter som dukker opp på resultatlister under kodenavn som *Obsidian, Vortex Shade og Quantum Crow.