Unlock exclusive introductory pricing for the newly launched Gemini 3.5 Flash.
X

Grok 4.20

ฤแบงu vร o:$1/M
ฤแบงu ra:$2/M
Bแป‘i cแบฃnh:2,000,000
Ngร y phรกt hร nh:Mar 11, 2026

Grok 4.20 release introduces a multi-agent architecture (multiple specialized agents coordinated in real time), expanded context modes, and focused improvements to instruction-following, hallucination reduction, and structured/tooled outputs.

Mแป›i
Sแปญ dแปฅng thฦฐฦกng mแบกi

Playground cho Grok 4.20

Khรกm phรก Playground cแปงa Grok 4.20 โ€” mรดi trฦฐแปng tฦฐฦกng tรกc ฤ‘แปƒ kiแปƒm tra mรด hรฌnh vร  chแบกy truy vแบฅn theo thแปi gian thแปฑc. Thแปญ prompts, ฤ‘iแปu chแป‰nh tham sแป‘ vร  lแบทp lแบกi ngay lแบญp tแปฉc ฤ‘แปƒ tฤƒng tแป‘c phรกt triแปƒn vร  xรกc thแปฑc cรกc trฦฐแปng hแปฃp sแปญ dแปฅng.

Technical Specifications of Grok-4.20

ItemGrok-4.20 (public specs)
Model familyGrok-4 series
DeveloperxAI
Release statusBeta (first rollout Feb 17, 2026)
Input typesText, Image, Video
Output typesText outputs (structured outputs & function/tool calling supported).
Context windowUp to 2,000,000 tokens
ArchitectureMulti-agent collaborative reasoning
Tool supportFunction calling, structured outputs
ReasoningBuilt-in reasoning capabilities
Training infrastructureColossus supercluster (~200,000 GPUs)
Model variantsgrok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

What is Grok-4.20

Grok-4.20 is the latest experimental release in the Grok-4 family developed by xAI. It focuses on agentic reasoning, extremely long context handling, and high-speed inference, aiming to deliver precise answers with a lower hallucination rate than earlier Grok models.

Unlike earlier Grok models that used single-model inference, Grok-4.20 introduces multi-agent collaboration, where several internal agents analyze a prompt simultaneously and converge on a final answer. This architecture is designed to improve performance on complex reasoning, coding, and research tasks.

Main Features of Grok-4.20

  • Ultra-long context window (2M tokens): Enables processing of entire books, large datasets, or long coding repositories in a single prompt.
  • Multi-agent reasoning architecture: Up to four internal agents can analyze a prompt in parallel and debate solutions before producing a final answer.
  • Agentic tool calling and structured outputs: Supports function calling and structured responses for integration with applications and automated workflows.
  • Multimodal understanding: Accepts text, image, and video inputs within the same model pipeline.
  • Fast inference with low hallucination focus: xAI positions the model as optimized for truthful answers and strong prompt adherence.

Benchmark Performance of Grok-4.20

Public benchmark data is still limited during beta, but early reports indicate:

BenchmarkResult / Status
LMSYS Chatbot ArenaEstimated ELO ~1505โ€“1535
ForecastBenchRanked #2 in early tests
Alpha Arena trading challengeAchieved +34.59% returns

These numbers suggest Grok-4.20 competes with frontier models in real-world reasoning and agent-driven tasks rather than simple benchmark questions.

Grok-4.20 Beta vs Other Frontier Models

ModelDeveloperContext WindowKey Strength
Grok-4.20xAI2M tokensMulti-agent reasoning
GPT-5.2OpenAI~400K tokensAdvanced reasoning + coding
Gemini 3 ProGoogle~1M tokensmultimodal and Google ecosystem
Claude 4 OpusAnthropic~200K+ tokensreliable reasoning

Key differences

  • Grok-4.20 emphasizes multi-agent collaboration for reasoning tasks.
  • It provides one of the largest context windows in production LLMs (2M tokens).
  • Competing models may outperform Grok in certain areas such as structured reasoning or creative writing depending on evaluation tasks.

Representative Use Cases

  1. Long-context research analysis
    Process large documents, legal materials, or academic research.
  2. Agentic automation systems
    Build multi-step workflows where the model plans and executes tasks.
  3. Advanced coding and simulations
    Solve engineering problems or simulate systems with long reasoning chains.
  4. Data analysis and dashboard automation
    Track and analyze multiple streams of data in parallel.
  5. Multimodal knowledge processing
    Interpret images, video frames, and text in a unified reasoning process.

How to access and use Grok 4.2 API

Step 1: Sign Up for API Key

Log in toย cometapi.com. If you are not our user yet, please register first. Sign into yourย CometAPI console. Get the access credential API key of the interface. Click โ€œAdd Tokenโ€ at the API token in the personal center, get the token key: sk-xxxxx and submit.

Step 2: Send Requests toย Grok 4.2ย API

Select the โ€œgrok-4.20-0309-reasoningโ€ endpoint to send the API request and set the request body. The request method and request body are obtained from our website API doc. Our website also provides Apifox test for your convenience. Replace <YOUR_API_KEY> with your actual CometAPI key from your account.ย Where to call it:ย ย ย Chatย format.

Insert your question or request into the content fieldโ€”this is what the model will respond to . Process the API response to get the generated answer.

Step 3: Retrieve and Verify Results

Process the API response to get the generated answer. After processing, the API responds with the task status and output data.

Cรขu Hแปi Thฦฐแปng Gแบทp

Giรก cแบฃ cho Grok 4.20

Khรกm phรก mแปฉc giรก cแบกnh tranh cho Grok 4.20, ฤ‘ฦฐแปฃc thiแบฟt kแบฟ ฤ‘แปƒ phรน hแปฃp vแป›i nhiแปu ngรขn sรกch vร  nhu cแบงu sแปญ dแปฅng khรกc nhau. Cรกc gรณi linh hoแบกt cแปงa chรบng tรดi ฤ‘แบฃm bแบฃo bแบกn chแป‰ trแบฃ tiแปn cho nhแปฏng gรฌ bแบกn sแปญ dแปฅng, giรบp dแป… dร ng mแปŸ rแป™ng quy mรด khi yรชu cแบงu cแปงa bแบกn tฤƒng lรชn. Khรกm phรก cรกch Grok 4.20 cรณ thแปƒ nรขng cao cรกc dแปฑ รกn cแปงa bแบกn trong khi vแบซn kiแปƒm soรกt ฤ‘ฦฐแปฃc chi phรญ.

ModelComet Price (USD / M Tokens)Official Price (USD / M Tokens)Discount
grok-4.20-0309-reasoning
ฤแบงu vร o:$1/M
ฤแบงu ra:$2/M
ฤแบงu vร o:$1.25/M
ฤแบงu ra:$2.5/M
-20%

Mรฃ mแบซu vร  API cho Grok 4.20

Truy cแบญp mรฃ mแบซu toร n diแป‡n vร  tร i nguyรชn API cho Grok 4.20 ฤ‘แปƒ tแป‘i ฦฐu hรณa quy trรฌnh tรญch hแปฃp cแปงa bแบกn. Tร i liแป‡u chi tiแบฟt cแปงa chรบng tรดi cung cแบฅp hฦฐแป›ng dแบซn tแปซng bฦฐแป›c, giรบp bแบกn khai thรกc toร n bแป™ tiแปm nฤƒng cแปงa Grok 4.20 trong cรกc dแปฑ รกn cแปงa mรฌnh.

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

Cรกc phiรชn bแบฃn cแปงa Grok 4.20

Lรฝ do Grok 4.20 cรณ nhiแปu snapshot cรณ thแปƒ bao gแป“m cรกc yแบฟu tแป‘ tiแปm nฤƒng nhฦฐ: sแปฑ thay ฤ‘แป•i ฤ‘แบงu ra sau cรกc bแบฃn cแบญp nhแบญt cแบงn cรกc snapshot cลฉ ฤ‘แปƒ ฤ‘แบฃm bแบฃo tรญnh nhแบฅt quรกn, cung cแบฅp cho nhร  phรกt triแปƒn thแปi gian chuyแปƒn tiแบฟp ฤ‘แปƒ thรญch แปฉng vร  di chuyแปƒn, cลฉng nhฦฐ cรกc snapshot khรกc nhau tฦฐฦกng แปฉng vแป›i cรกc endpoint toร n cแบงu hoแบทc khu vแปฑc nhแบฑm tแป‘i ฦฐu hรณa trแบฃi nghiแป‡m ngฦฐแปi dรนng. ฤแปƒ biแบฟt chi tiแบฟt vแป sแปฑ khรกc biแป‡t giแปฏa cรกc phiรชn bแบฃn, vui lรฒng tham khแบฃo tร i liแป‡u chรญnh thแปฉc.

Model iddescriptionAvailabilityRequest
grok-4.20-multi-agent-beta-0309Multi-agent variant tuned for realtime agent orchestration and tool calling (useful for deep research workflows where multiple sub-agents perform web searches, code execution, and critique).โœ…response format calls.
grok-4.20-0309-reasoningReasoning-optimized variant: prioritizes deeper chain-of-thought style reasoning and higher benchmark scores on reasoning-heavy tests; higher latency/cost per token expected versus non-reasoning variants.โœ…chat format call and response format calls.
grok-4.20-0309-non-reasoningLower-latency / lower-cost variant for high-throughput tasks where deterministic, short answers or streaming outputs are the priority; tradeoffs include lower reasoning benchmark scores.โœ…chat format call and response format calls.