Claude Opus 5 is now live on CometAPI โ†’
X

Grok 4.20

Eingabe:$1/M
Ausgabe:$2/M
Kontext:2,000,000
Verรถffentlicht:Mar 11, 2026

Das Release Grok 4.20 fรผhrt eine Multi-Agenten-Architektur (mehrere spezialisierte Agenten, die in Echtzeit koordiniert werden), erweiterte Kontextmodi sowie gezielte Verbesserungen beim Befolgen von Anweisungen, bei der Reduzierung von Halluzinationen und bei strukturierten/werkzeuggestรผtzten Ausgaben ein.

Neu
Kommerzielle Nutzung

Playground fรผr Grok 4.20

Erkunden Sie Grok 4.20's Playground โ€” eine interaktive Umgebung zum Testen von Modellen und Ausfรผhren von Abfragen in Echtzeit. Probieren Sie Prompts aus, passen Sie Parameter an und iterieren Sie sofort, um die Entwicklung zu beschleunigen und Anwendungsfรคlle zu validieren.

Technische Spezifikationen von Grok-4.20

ElementGrok-4.20 (รถffentliche Spezifikationen)
ModellfamilieGrok-4-Serie
EntwicklerxAI
Release-StatusBeta (erster Rollout am 17. Feb. 2026)
EingabetypenText, Bild, Video
AusgabetypenTextausgaben (strukturierte Ausgaben und Funktions-/Tool-Aufrufe werden unterstรผtzt).
KontextfensterBis zu 2,000,000 Token
ArchitekturKollaboratives Schlussfolgern mit mehreren Agenten
Tool-UnterstรผtzungFunktionsaufrufe, strukturierte Ausgaben
SchlussfolgernIntegrierte Schlussfolgerungsfรคhigkeiten
TrainingsinfrastrukturColossus supercluster (~200,000 GPUs)
Modellvariantengrok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

Was ist Grok-4.20

Grok-4.20 ist die neueste experimentelle Verรถffentlichung in der Grok-4-Familie von xAI. Der Fokus liegt auf agentischem Schlussfolgern, extrem langer Kontextverarbeitung und Hochgeschwindigkeits-Inferenz, mit dem Ziel, prรคzise Antworten mit einer niedrigeren Halluzinationsrate als frรผhere Grok-Modelle zu liefern.

Im Gegensatz zu frรผheren Grok-Modellen, die Einzeltmodell-Inferenz verwendeten, fรผhrt Grok-4.20 eine Multi-Agenten-Kollaboration ein, bei der mehrere interne Agenten eine Eingabe gleichzeitig analysieren und sich auf eine finale Antwort einigen. Diese Architektur soll die Leistung bei komplexem Schlussfolgern, Programmierung und Rechercheaufgaben verbessern.

Hauptfunktionen von Grok-4.20

  • Ultralanges Kontextfenster (2M tokens): Ermรถglicht die Verarbeitung ganzer Bรผcher, groรŸer Datensรคtze oder umfangreicher Code-Repositories in einer einzigen Eingabe.
  • Multi-Agenten-Architektur fรผr das Schlussfolgern: Bis zu vier interne Agenten kรถnnen eine Eingabe parallel analysieren und Lรถsungen diskutieren, bevor eine finale Antwort erzeugt wird.
  • Agentische Tool-Aufrufe und strukturierte Ausgaben: Unterstรผtzt Funktionsaufrufe und strukturierte Antworten zur Integration in Anwendungen und automatisierte Workflows.
  • Multimodales Verstรคndnis: Akzeptiert Text-, Bild- und Videoeingaben innerhalb derselben Modell-Pipeline.
  • Schnelle Inferenz mit Fokus auf geringe Halluzinationsrate: xAI positioniert das Modell als optimiert fรผr wahrheitsgetreue Antworten und hohe Prompt-Einhaltung.

Benchmark-Leistung von Grok-4.20

ร–ffentliche Benchmark-Daten sind in der Beta-Phase noch begrenzt, aber frรผhe Berichte deuten darauf hin:

BenchmarkErgebnis / Status
LMSYS Chatbot ArenaGeschรคtzte ELO ~1505โ€“1535
ForecastBenchIn frรผhen Tests auf Platz #2
Alpha Arena trading challengeErreichte +34.59% Rendite

Diese Zahlen deuten darauf hin, dass Grok-4.20 mit Spitzenmodellen bei praxisnahen Schlussfolgerungs- und agentengesteuerten Aufgaben konkurriert, statt nur bei einfachen Benchmark-Fragen.

Grok-4.20 Beta vs andere Spitzenmodelle

ModellEntwicklerKontextfensterKernstรคrke
Grok-4.20xAI2M tokensMulti-Agenten-Schlussfolgern
GPT-5.2OpenAI~400K tokensFortgeschrittenes Schlussfolgern + Programmierung
Gemini 3 ProGoogle~1M tokensmultimodal und Google-ร–kosystem
Claude 4 OpusAnthropic~200K+ tokenszuverlรคssiges Schlussfolgern

Wesentliche Unterschiede

  • Grok-4.20 legt den Schwerpunkt auf Multi-Agenten-Kollaboration fรผr Schlussfolgerungsaufgaben.
  • Es bietet eines der grรถรŸten Kontextfenster unter produktiven LLMs (2M tokens).
  • Konkurrenzmodelle kรถnnen je nach Evaluationsaufgabe Grok in bestimmten Bereichen wie strukturiertem Schlussfolgern oder kreativem Schreiben รผbertreffen.

Reprรคsentative Anwendungsfรคlle

  1. Rechercheanalyse mit langem Kontext
    GroรŸe Dokumente, juristische Materialien oder akademische Forschung verarbeiten.
  2. Agentenbasierte Automatisierungssysteme
    Mehrstufige Workflows aufbauen, in denen das Modell Aufgaben plant und ausfรผhrt.
  3. Fortgeschrittenes Programmieren und Simulationen
    Ingenieurprobleme lรถsen oder Systeme mit langen Schlussfolgerungsketten simulieren.
  4. Datenanalyse und Dashboard-Automatisierung
    Mehrere Datenstrรถme parallel verfolgen und analysieren.
  5. Multimodale Wissensverarbeitung
    Bilder, Videoframes und Text in einem einheitlichen Schlussfolgerungsprozess interpretieren.

Zugriff auf und Nutzung der Grok 4.2 API

Schritt 1: Fรผr API-Schlรผssel registrieren

Melden Sie sich bei cometapi.com an. Wenn Sie noch kein Nutzer sind, registrieren Sie sich bitte zuerst. Melden Sie sich bei Ihrer CometAPI console an. Rufen Sie den Zugangs-API-Schlรผssel der Schnittstelle ab. Klicken Sie im persรถnlichen Bereich beim API-Token auf โ€žAdd Tokenโ€œ, erhalten Sie den Token-Schlรผssel: sk-xxxxx und senden Sie ihn ab.

Schritt 2: Anfragen an die Grok 4.2 API senden

Wรคhlen Sie den โ€žgrok-4.20-0309-reasoningโ€œ-Endpoint, um die API-Anfrage zu senden, und legen Sie den Request-Body fest. Die Request-Methode und der Request-Body stammen aus der API-Dokumentation auf unserer Website. Unsere Website stellt auรŸerdem einen Apifox-Test zu Ihrer Bequemlichkeit bereit. Ersetzen Sie <YOUR_API_KEY> durch Ihren tatsรคchlichen CometAPI-Schlรผssel aus Ihrem Konto. Wo es aufgerufen wird: Chat Format.

Fรผgen Sie Ihre Frage oder Anfrage in das content-Feld einโ€”darauf antwortet das Modell. Verarbeiten Sie die API-Antwort, um die generierte Antwort zu erhalten.

Schritt 3: Ergebnisse abrufen und verifizieren

Verarbeiten Sie die API-Antwort, um die generierte Antwort zu erhalten. Nach der Verarbeitung antwortet die API mit dem Aufgabenstatus und den Ausgabedaten.

FAQ

Preise fรผr Grok 4.20

Entdecken Sie wettbewerbsfรคhige Preise fรผr Grok 4.20, die fรผr verschiedene Budgets und Nutzungsanforderungen konzipiert sind. Unsere flexiblen Tarife stellen sicher, dass Sie nur fรผr das bezahlen, was Sie nutzen, und erleichtern die Skalierung entsprechend Ihren wachsenden Anforderungen. Erfahren Sie, wie Grok 4.20 Ihre Projekte verbessern kann, wรคhrend die Kosten รผberschaubar bleiben.

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

Beispielcode und API fรผr Grok 4.20

Greifen Sie auf umfassende Beispielcodes und API-Ressourcen fรผr Grok 4.20 zu, um Ihren Integrationsprozess zu optimieren. Unsere detaillierte Dokumentation bietet schrittweise Anleitungen und hilft Ihnen dabei, das volle Potenzial von Grok 4.20 in Ihren Projekten zu nutzen.

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

Versionen von Grok 4.20

Der Grund, warum Grok 4.20 mehrere Snapshots hat, kann potenzielle Faktoren wie ร„nderungen der Ausgabe nach Updates umfassen, die รคltere Snapshots fรผr Konsistenz erfordern, Entwicklern eine รœbergangszeit fรผr Anpassung und Migration bieten und verschiedene Snapshots, die globalen oder regionalen Endpunkten entsprechen, um das Benutzererlebnis zu optimieren. Fรผr detaillierte Unterschiede zwischen den Versionen lesen Sie bitte die offizielle Dokumentation.

Modell-IDBeschreibungVerfรผgbarkeitAnfrage
grok-4.20-multi-agent-beta-0309Multi-Agenten-Variante, abgestimmt auf die Orchestrierung von Agenten in Echtzeit und Tool-Aufrufe (nรผtzlich fรผr umfangreiche Recherche-Workflows, in denen mehrere Sub-Agenten Websuchen, Codeausfรผhrung und kritische Bewertung durchfรผhren).โœ…Aufrufe im Response-Format.
grok-4.20-0309-reasoningFรผr Reasoning optimierte Variante: priorisiert tiefergehendes Denken im Chain-of-Thought-Stil und hรถhere Benchmark-Werte bei reasoning-lastigen Tests; gegenรผber Nicht-Reasoning-Varianten sind hรถhere Latenz/Kosten pro Token zu erwarten.โœ…Aufruf im Chat-Format und Aufrufe im Response-Format.
grok-4.20-0309-non-reasoningVariante mit geringerer Latenz und geringeren Kosten fรผr High-Throughput-Aufgaben, bei denen deterministische, kurze Antworten oder Streaming-Ausgaben Prioritรคt haben; Kompromisse umfassen niedrigere Reasoning-Benchmark-Werte.โœ…Aufruf im Chat-Format und Aufrufe im Response-Format.