What makes Grok-4.20 different from previous Grok models?

Grok-4.20 führt ein Multiagenten-Reasoning-System ein, bei dem mehrere Agenten eine Eingabeaufforderung gleichzeitig analysieren und gemeinsam eine finale Antwort erarbeiten, was komplexes Reasoning und die Programmierleistung verbessert.

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

Grok-4.20 unterstützt ein 2,000,000-Token-Kontextfenster und ermöglicht es Entwicklern, extrem lange Dokumente oder Datensätze in einer einzigen Anfrage zu verarbeiten.

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

Ja. Grok-4.20 unterstützt multimodale Eingaben, darunter Text, Bilder und Videos, und ermöglicht die Analyse gemischter Inhalte innerhalb einer einzigen Unterhaltung.

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

Grok-4.20 konzentriert sich auf Multiagenten-Reasoning und sehr lange Kontextfenster, während GPT-5.2 auf hochpräzises Reasoning setzt und Gemini-Modelle die multimodale Integration innerhalb des Google-Ökosystems in den Vordergrund stellen.

Is Grok-4.20 available through an API for developers?

Ja. Grok-4.20 ist über die Come API verfügbar.

What benchmarks show Grok-4.20 performance?

Frühe Berichte verorten Grok-4.20 bei etwa 1505–1535 ELO auf der LMSYS Arena und zeigen starke Ergebnisse in realen Wettbewerben wie Alpha Arena-Handelssimulationen.

Erschwingliche Grok 4.20 API | text-to-text

Technische Spezifikationen von Grok-4.20

Element	Grok-4.20 (öffentliche Spezifikationen)
Modellfamilie	Grok-4-Serie
Entwickler	xAI
Release-Status	Beta (erster Rollout am 17. Feb. 2026)
Eingabetypen	Text, Bild, Video
Ausgabetypen	Textausgaben (strukturierte Ausgaben und Funktions-/Tool-Aufrufe werden unterstützt).
Kontextfenster	Bis zu 2,000,000 Token
Architektur	Kollaboratives Schlussfolgern mit mehreren Agenten
Tool-Unterstützung	Funktionsaufrufe, strukturierte Ausgaben
Schlussfolgern	Integrierte Schlussfolgerungsfähigkeiten
Trainingsinfrastruktur	Colossus supercluster (~200,000 GPUs)
Modellvarianten	grok-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:

Benchmark	Ergebnis / Status
LMSYS Chatbot Arena	Geschätzte ELO ~1505–1535
ForecastBench	In frühen Tests auf Platz #2
Alpha Arena trading challenge	Erreichte +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

Modell	Entwickler	Kontextfenster	Kernstärke
Grok-4.20	xAI	2M tokens	Multi-Agenten-Schlussfolgern
GPT-5.2	OpenAI	~400K tokens	Fortgeschrittenes Schlussfolgern + Programmierung
Gemini 3 Pro	Google	~1M tokens	multimodal und Google-Ökosystem
Claude 4 Opus	Anthropic	~200K+ tokens	zuverlä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

Rechercheanalyse mit langem Kontext
Große Dokumente, juristische Materialien oder akademische Forschung verarbeiten.
Agentenbasierte Automatisierungssysteme
Mehrstufige Workflows aufbauen, in denen das Modell Aufgaben plant und ausführt.
Fortgeschrittenes Programmieren und Simulationen
Ingenieurprobleme lösen oder Systeme mit langen Schlussfolgerungsketten simulieren.
Datenanalyse und Dashboard-Automatisierung
Mehrere Datenströme parallel verfolgen und analysieren.
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.

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.

Comet-Preis (USD / M Tokens)	Offizieller Preis (USD / M Tokens)	Rabatt
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.

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

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-ID	Beschreibung	Verfügbarkeit	Anfrage
grok-4.20-multi-agent-beta-0309	Multi-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-reasoning	Fü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-reasoning	Variante 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.