ModellePreiseUnternehmen
500+ KI-Modell-APIs, Alles in einer API. Nur bei CometAPI
Modelle-API
Entwickler
SchnellstartDokumentationAPI Dashboard
Unternehmen
Über unsUnternehmen
Ressourcen
KI-ModelleBlogÄnderungsprotokollSupport
NutzungsbedingungenDatenschutzrichtlinie
© 2026 CometAPI · All rights reserved
Home/Models/xAI/Grok 4.20
X

Grok 4.20

Eingabe:$1.6/M
Ausgabe:$4.8/M
Kontext:2,000,000
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
Überblick
Funktionen
Preisgestaltung
API
Versionen

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

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.

Funktionen für Grok 4.20

Entdecken Sie die wichtigsten Funktionen von Grok 4.20, 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

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

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.

Weitere Modelle

C

Claude Opus 4.7

Eingabe:$3/M
Ausgabe:$15/M
Das intelligenteste Modell für Agenten und Programmierung
A

Claude Sonnet 4.6

Eingabe:$2.4/M
Ausgabe:$12/M
Claude Sonnet 4.6 ist unser bisher leistungsfähigstes Sonnet-Modell. Es ist ein umfassendes Upgrade der Fähigkeiten des Modells in den Bereichen Programmierung, Computernutzung, Schlussfolgern mit langem Kontext, Agentenplanung, Wissensarbeit und Design. Sonnet 4.6 bietet außerdem ein 1M-Token-Kontextfenster in Beta.
O

GPT 5.5 Pro

Eingabe:$24/M
Ausgabe:$144/M
Ein fortschrittliches Modell, das für äußerst komplexe Logik und professionelle Anforderungen entwickelt wurde und den höchsten Standard tiefgreifenden Schlussfolgerns und präziser analytischer Fähigkeiten repräsentiert.
O

GPT 5.5

Eingabe:$4/M
Ausgabe:$24/M
Ein multimodales Flaggschiffmodell der nächsten Generation, das außergewöhnliche Leistungsfähigkeit mit effizienter Antwortgenerierung vereint und der Bereitstellung umfassender und stabiler KI-Dienste für allgemeine Zwecke gewidmet ist.
O

GPT Image 2 ALL

Pro Anfrage:$0.04
GPT Image 2 ist das modernste Bildgenerierungsmodell von openai für schnelle, hochwertige Bildgenerierung und -bearbeitung. Es unterstützt flexible Bildgrößen und Bildeingaben mit hoher Detailtreue.
O

GPT 5.5 ALL

Eingabe:$4/M
Ausgabe:$24/M
GPT-5.5 überzeugt beim Schreiben von Code, bei der Online-Recherche, bei der Datenanalyse und bei toolübergreifenden Operationen. Das Modell steigert nicht nur seine Autonomie bei der Bewältigung komplexer, mehrstufiger Aufgaben, sondern verbessert bei gleichbleibender Latenz im Vergleich zu seinem Vorgänger auch die Fähigkeiten zum logischen Schlussfolgern und die Ausführungseffizienz erheblich, was einen wichtigen Schritt in Richtung automatisierter Büroautomatisierung in der KI markiert.

Verwandte Blogs

Cursor Composer vs Windsurf vs GitHub Copilot: Preise & was Sie wirklich bekommen
Apr 20, 2026
copilot
composer-2
windsurf

Cursor Composer vs Windsurf vs GitHub Copilot: Preise & was Sie wirklich bekommen

Wenn Sie das beste autonome Ergebnis möchten, liegt Cursor meist vorn. Wenn Sie das reibungsloseste geführte Editieren möchten, ist Windsurf oft am komfortabelsten. Wenn Sie den besten GitHub-nativen Workflow pro Dollar möchten, ist Copilot am praktischsten. Diese Rangfolge ist eine Schlussfolgerung aus den aktuellen Produktdesigns, der Preisgestaltung und den Agentenmodellen, die von jedem Anbieter veröffentlicht wurden.
Was ist Grok 4.2: Funktionen, Architektur und Vergleiche
Mar 12, 2026
grok-4-2

Was ist Grok 4.2: Funktionen, Architektur und Vergleiche

Grok 4.2 ist das Public-Beta-Flaggschiff von xAI innerhalb der Grok-4-Familie: ein Multi-Agenten-Generationsmodell mit Tool-Unterstützung, branchenführendem Durchsatz, einem riesigen 2,000,000-Token-Kontextfenster im Agentenmodus und spezialisierten API-Varianten wie grok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning und grok-4.20-beta-0309-non-reasoning. Es ist für schnelle, agentische Workflows (Echtzeit-X-Daten / Tool-Aufrufe) optimiert, ist im Web, auf iOS/Android und in frühen API-Kanälen, z. B. CometAPI, verfügbar und richtet sich an Nutzer, die schnelle, live-datenbewusste Assistenten benötigen, statt an diejenigen, die das tiefgehendste Langform-Reasoning verlangen.
So verwenden Sie die Grok 4.2 API im Jahr 2026
Mar 12, 2026
grok-4-2

So verwenden Sie die Grok 4.2 API im Jahr 2026

Grok 4.2 ist xAIs neuestes Multi-Agenten-Reasoning-Modell, das vier zusammenarbeitende Agenten und neue agentenbasierte Tool-Calling-Funktionen kombiniert, um für Enterprise-Workloads eine deutlich schnellere Inferenz mit weniger Halluzinationen bereitzustellen. Um es heute aufzurufen, verwenden die meisten Entwickler entweder (a) die offiziellen xAI-REST/gRPC-Endpunkte oder (b) rufen es über einen Aggregator wie CometAPI auf (ein einzelner REST-Endpunkt,post https://api.cometapi.com/v1/responsess), der API-Keys, Abrechnung und den Wechsel zwischen mehreren Modellen vereinfacht.
Grok 4.2: Was es bringen wird und warum es 2026 für die KI wichtig ist
Jan 18, 2026
grok-4-2

Grok 4.2: Was es bringen wird und warum es 2026 für die KI wichtig ist

Grok 4.2 ist eine ausgefeilte Iteration von Elon Musks Flaggschiffmodell. Im Gegensatz zu seinen Vorgängern ist Grok 4.2 über eine Reihe von "Stealth-Checkpoints" erschienen—mysteriöse Modellvarianten, die auf Bestenlisten unter Codenamen wie *Obsidian, Vortex Shade und Quantum Crow auftauchen.