Home/Models/xAI/Grok 4.20 Beta
X

Grok 4.20 Beta

Eingabe:$1.6/M
Ausgabe:$4.8/M
Kontext:2,000,000
Grok 4.20 Beta ist unser neuestes Flaggschiffmodell mit branchenführender Geschwindigkeit und Fähigkeiten für agentische Tool-Aufrufe. Es vereint die niedrigste Halluzinationsrate am Markt mit strikter Einhaltung von Prompts und liefert durchgängig präzise und wahrheitsgetreue Antworten.
Neu
Kommerzielle Nutzung
Playground
Überblick
Funktionen
Preisgestaltung
API
Versionen

Technische Spezifikationen von Grok-4.20 Beta

ParameterGrok-4.20 Beta (öffentliche Spezifikationen)
ModellfamilieGrok-4 series
EntwicklerxAI
VeröffentlichungsstatusBeta (erste Einführung am 17. Feb. 2026)
EingabetypenText, Bild, Video
AusgabetypenTextausgaben (strukturierte Ausgaben & Funktions-/Tool-Aufrufe werden unterstützt).
KontextfensterBis zu 2,000,000 Token
ArchitekturKollaboratives Multi-Agenten-Reasoning
Tool-UnterstützungFunktionsaufrufe, strukturierte Ausgaben
ReasoningEingebaute Reasoning-Fä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 Beta

Grok-4.20 Beta ist die neueste experimentelle Veröffentlichung der Grok-4-Familie von xAI. Der Fokus liegt auf agentenbasiertem Reasoning, extrem langer Kontextverarbeitung und Hochgeschwindigkeitsinferenz, um präzise Antworten mit einer niedrigeren Halluzinationsrate als frühere Grok-Modelle zu liefern.

Im Gegensatz zu früheren Grok-Modellen mit Einzelmodell-Inferenz führt Grok-4.20 Multi-Agenten-Zusammenarbeit ein, bei der mehrere interne Agenten eine Eingabe gleichzeitig analysieren und sich auf eine endgültige Antwort einigen. Diese Architektur ist darauf ausgelegt, die Leistung bei komplexem Reasoning, Programmierung und Forschungsaufgaben zu 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-Reasoning-Architektur: Bis zu vier interne Agenten können eine Eingabe parallel analysieren und Lösungen diskutieren, bevor sie eine endgültige Antwort erzeugen.
  • Agentenbasierte 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 Halluzinationen: xAI positioniert das Modell als optimiert für wahrheitsgetreue Antworten und hohe Prompt-Treue.

Benchmark-Leistung von Grok-4.20 Beta

Öffentliche Benchmark-Daten sind in der Beta noch begrenzt, aber frühe Berichte deuten darauf hin:

BenchmarkErgebnis / Status
LMSYS Chatbot ArenaGeschätzte ELO ~1505–1535
ForecastBenchRang #2 in frühen Tests
Alpha Arena trading challengeErzielte +34.59% Rendite

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

Grok-4.20 Beta vs. andere Spitzenmodelle

ModellEntwicklerKontextfensterSchlüsselstärke
Grok-4.20 BetaxAI2M tokensMulti-Agenten-Reasoning
GPT-5.2OpenAI~400K tokensFortgeschrittenes Reasoning + Coding
Gemini 3 ProGoogle~1M tokensMultimodal und Google-Ökosystem
Claude 4 OpusAnthropic~200K+ tokensZuverlässiges Reasoning

Wesentliche Unterschiede

  • Grok-4.20 betont die Multi-Agenten-Zusammenarbeit für Reasoning-Aufgaben.
  • Es bietet eines der größten Kontextfenster in produktiven LLMs (2M tokens).
  • Konkurrenzmodelle können Grok je nach Bewertungsaufgabe in bestimmten Bereichen wie strukturiertem Reasoning oder kreativem Schreiben übertreffen.

Repräsentative Anwendungsfälle

  1. Forschungsanalysen mit langem Kontext
    Verarbeitung großer Dokumente, juristischer Materialien oder akademischer Forschung.
  2. Agentenbasierte Automatisierungssysteme
    Aufbau mehrstufiger Workflows, in denen das Modell Aufgaben plant und ausführt.
  3. Fortgeschrittene Programmierung und Simulationen
    Lösung technischer Probleme oder Simulation von Systemen mit langen Reasoning-Ketten.
  4. Datenanalyse und Dashboard-Automatisierung
    Paralleles Verfolgen und Analysieren mehrerer Datenströme.
  5. Multimodale Wissensverarbeitung
    Interpretation von Bildern, Videoframes und Text in einem einheitlichen Reasoning-Prozess.

Zugriff auf und Verwendung der Grok 4.2 API

Schritt 1: Für API-Schlüssel registrieren

Melden Sie sich bei cometapi.com an. Falls Sie noch kein Nutzer sind, registrieren Sie sich bitte zuerst. Melden Sie sich in Ihrer CometAPI-Konsole an. Rufen Sie den API-Schlüssel für den Zugriff auf die Schnittstelle ab. Klicken Sie bei den API-Token im persönlichen Bereich auf „Add Token“, erhalten Sie den Token-Key: sk-xxxxx und übermitteln Sie ihn.

Schritt 2: Anfragen an die Grok 4.2 API senden

Wählen Sie den „grok-4.20-beta-0309-reasoning“-Endpunkt, um die API-Anfrage zu senden, und legen Sie den Request-Body fest. Anfragemethode und Request-Body sind der API-Dokumentation auf unserer Website zu entnehmen. Unsere Website stellt außerdem einen Apifox-Test zu Ihrer Verfügung. Ersetzen Sie <YOUR_API_KEY> durch Ihren tatsächlichen CometAPI-Schlüssel aus Ihrem Konto. Wo der Aufruf erfolgt: 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 gibt die API den Aufgabenstatus und die Ausgabedaten zurück.

FAQ

What makes Grok-4.20 Beta different from previous Grok models?

Grok-4.20 Beta führt ein Multi-Agenten-Reasoning-System ein, bei dem mehrere Agenten eine Eingabe gleichzeitig analysieren und gemeinsam an einer endgültigen Antwort arbeiten, was das komplexe Schlussfolgern und die Leistung beim Programmieren verbessert.

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

Grok-4.20 Beta unterstützt ein Kontextfenster von bis zu 2,000,000 Token, wodurch Entwickler extrem lange Dokumente oder Datensätze in einer einzigen Anfrage verarbeiten können.

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

Ja. Grok-4.20 Beta unterstützt multimodale Eingaben, einschließlich Text, Bildern und Videos, wodurch gemischte Inhalte innerhalb eines einzigen Gesprächs analysiert werden können.

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

Grok-4.20 konzentriert sich auf Multi-Agenten-Reasoning und sehr lange Kontextfenster, während GPT-5.2 hochgenaues Reasoning betont und Gemini-Modelle den Fokus auf multimodale Integration innerhalb des Google-Ökosystems legen.

Is Grok-4.20 Beta available through an API for developers?

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

What benchmarks show Grok-4.20 Beta performance?

Frühe Berichte verorten Grok-4.20 Beta bei etwa 1505–1535 ELO auf der LMSYS Arena und berichten von starken Ergebnissen in realen Wettbewerben wie den Alpha Arena-Handelssimulationen.

Funktionen für Grok 4.20 Beta

Entdecken Sie die wichtigsten Funktionen von Grok 4.20 Beta, die darauf ausgelegt sind, Leistung und Benutzerfreundlichkeit zu verbessern. Erfahren Sie, wie diese Fähigkeiten Ihren Projekten zugutekommen und die Benutzererfahrung verbessern können.

Preise für Grok 4.20 Beta

Entdecken Sie wettbewerbsfähige Preise für Grok 4.20 Beta, 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 Beta Ihre Projekte verbessern kann, während die Kosten überschaubar bleiben.
Comet-Preis (USD / M Tokens)Offizieller Preis (USD / M Tokens)Rabatt
Eingabe:$1.6/M
Ausgabe:$4.8/M
Eingabe:$2/M
Ausgabe:$6/M
-20%

Beispielcode und API für Grok 4.20 Beta

Greifen Sie auf umfassende Beispielcodes und API-Ressourcen für Grok 4.20 Beta zu, um Ihren Integrationsprozess zu optimieren. Unsere detaillierte Dokumentation bietet schrittweise Anleitungen und hilft Ihnen dabei, das volle Potenzial von Grok 4.20 Beta 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))

Versionen von Grok 4.20 Beta

Der Grund, warum Grok 4.20 Beta 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-Agent-Variante, optimiert für die Echtzeit-Orchestrierung von Agenten und Tool-Aufrufe (nützlich für tiefgehende Recherche-Workflows, bei denen mehrere Unteragenten Websuchen, Codeausführung und Begutachtung übernehmen).✅Antwortformat-Aufrufe.
grok-4.20-beta-0309-reasoningFür Reasoning optimierte Variante: priorisiert tiefergehendes Chain-of-Thought-ähnliches Denken und höhere Benchmark-Ergebnisse bei reasoning-lastigen Tests; im Vergleich zu Varianten ohne Reasoning ist mit höherer Latenz/Kosten pro Token zu rechnen.✅Chat-Format-Aufruf und Antwortformat-Aufrufe.
grok-4.20-beta-0309-non-reasoningVariante mit geringerer Latenz/geringeren Kosten für Aufgaben mit hohem Durchsatz, bei denen deterministische, kurze Antworten oder Streaming-Ausgaben Priorität haben; Kompromisse umfassen niedrigere Reasoning-Benchmark-Ergebnisse.✅Chat-Format-Aufruf und Antwortformat-Aufrufe.

Weitere Modelle