What makes Grok-4.20 different from previous Grok models?

Grok-4.20 นำเสนอระบบให้เหตุผลแบบหลายเอเจนต์ ซึ่งเอเจนต์หลายตัวจะวิเคราะห์พรอมต์พร้อมกันและร่วมกันสรุปคำตอบสุดท้าย ช่วยเพิ่มความสามารถในการให้เหตุผลที่ซับซ้อนและประสิทธิภาพด้านการเขียนโค้ด.

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

Grok-4.20 รองรับหน้าต่างบริบทได้สูงสุด 2,000,000 โทเค็น ช่วยให้นักพัฒนาสามารถประมวลผลเอกสารหรือชุดข้อมูลที่ยาวมากได้ภายในคำขอเดียว.

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

ใช่. Grok-4.20 รองรับอินพุตแบบมัลติโมดัล รวมถึงข้อความ รูปภาพ และวิดีโอ ทำให้สามารถวิเคราะห์เนื้อหาหลายรูปแบบภายในการสนทนาเดียว.

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

Grok-4.20 มุ่งเน้นการให้เหตุผลแบบหลายเอเจนต์และหน้าต่างบริบทที่ยาวมาก ในขณะที่ GPT-5.2 เน้นการให้เหตุผลความแม่นยำสูง และ Gemini มุ่งเน้นการบูรณาการแบบมัลติโมดัลภายในระบบนิเวศของ Google.

Is Grok-4.20 available through an API for developers?

ใช่. Grok-4.20 มีให้ใช้งานผ่าน Come API.

What benchmarks show Grok-4.20 performance?

รายงานเบื้องต้นระบุว่า Grok-4.20 อยู่ที่ประมาณ 1505–1535 ELO บน LMSYS Arena และทำผลงานได้ดีในการแข่งขันจริง เช่น การจำลองการเทรดของ Alpha Arena.

API Grok 4.20 ราคาประหยัด | text-to-text

ข้อมูลจำเพาะทาง技术ของ Grok-4.20

รายการ	Grok-4.20 (ข้อมูลจำเพาะสาธารณะ)
ตระกูลโมเดล	ซีรีส์ Grok-4
ผู้พัฒนา	xAI
สถานะการเปิดตัว	Beta (เผยแพร่ชุดแรก 17 ก.พ. 2026)
ชนิดอินพุต	ข้อความ, รูปภาพ, วิดีโอ
ชนิดเอาต์พุต	ผลลัพธ์เป็นข้อความ (รองรับผลลัพธ์แบบมีโครงสร้างและการเรียกใช้ฟังก์ชัน/เครื่องมือ)
หน้าต่างบริบท	ได้สูงสุด 2,000,000 โทเค็น
สถาปัตยกรรม	การให้เหตุผลแบบร่วมมือของหลายเอเจนต์
การรองรับเครื่องมือ	การเรียกใช้ฟังก์ชัน, ผลลัพธ์แบบมีโครงสร้าง
การให้เหตุผล	ความสามารถในการให้เหตุผลในตัว
โครงสร้างพื้นฐานการฝึก	คลัสเตอร์ยักษ์ Colossus (~200,000 GPU)
รุ่นย่อยของโมเดล	grok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

Grok-4.20 คืออะไร

Grok-4.20 เป็นรุ่นทดลองล่าสุดในตระกูล Grok-4 ที่พัฒนาโดย xAI มุ่งเน้นที่การให้เหตุผลแบบเอเจนต์ การจัดการบริบทที่ยาวมากเป็นพิเศษ และการอนุมานความเร็วสูง โดยมีเป้าหมายเพื่อให้คำตอบที่แม่นยำพร้อมอัตรา hallucination ต่ำกว่ารุ่นก่อนของ Grok

แตกต่างจากโมเดล Grok รุ่นก่อนที่ใช้การอนุมานด้วยโมเดลเดี่ยว Grok-4.20 นำเสนอการทำงานร่วมกันของหลายเอเจนต์ โดยเอเจนต์ภายในหลายตัวจะวิเคราะห์พรอมป์พร้อมกันและบรรจบเป็นคำตอบสุดท้าย สถาปัตยกรรมนี้ออกแบบมาเพื่อปรับปรุงประสิทธิภาพในงานให้เหตุผลซับซ้อน การเขียนโค้ด และงานวิจัย

คุณสมบัติหลักของ Grok-4.20

หน้าต่างบริบทยาวเป็นพิเศษ (2M โทเค็น): ช่วยให้ประมวลผลหนังสือทั้งเล่ม ชุดข้อมูลขนาดใหญ่ หรือรีโปซิทอรีโค้ดขนาดยาวได้ในพรอมป์เดียว
สถาปัตยกรรมให้เหตุผลแบบหลายเอเจนต์: มีเอเจนต์ภายในได้ถึงสี่ตัวที่สามารถวิเคราะห์พรอมป์แบบขนานและอภิปรายแนวทางก่อนให้คำตอบสุดท้าย
การเรียกใช้เครื่องมือแบบเอเจนต์และผลลัพธ์แบบมีโครงสร้าง: รองรับการเรียกใช้ฟังก์ชันและการตอบแบบมีโครงสร้างเพื่อผสานกับแอปพลิเคชันและเวิร์กโฟลว์อัตโนมัติ
ความเข้าใจแบบมัลติโหมด: รองรับอินพุตข้อความ รูปภาพ และวิดีโอภายในสายงานโมเดลเดียวกัน
การอนุมานรวดเร็วโดยเน้นลด hallucination: xAI ระบุว่าโมเดลได้รับการปรับให้เหมาะสำหรับคำตอบที่ตรงความจริงและยึดตามพรอมป์อย่างเคร่งครัด

ผลการทดสอบมาตรฐานของ Grok-4.20

ข้อมูลเบนช์มาร์กแบบสาธารณะยังมีจำกัดในช่วงเบต้า แต่รายงานเบื้องต้นระบุว่า:

เบนช์มาร์ก	ผลลัพธ์ / สถานะ
LMSYS Chatbot Arena	ELO โดยประมาณ ~1505–1535
ForecastBench	จัดอันดับ #2 ในการทดสอบเบื้องต้น
Alpha Arena trading challenge	ทำผลตอบแทนได้ +34.59%

ตัวเลขเหล่านี้บ่งชี้ว่า Grok-4.20 สามารถแข่งขันกับโมเดลแนวหน้าสำหรับงานให้เหตุผลและงานที่ขับเคลื่อนด้วยเอเจนต์ในสถานการณ์จริง มากกว่าคำถามเบนช์มาร์กอย่างง่าย

Grok-4.20 Beta เทียบกับโมเดลแนวหน้าอื่น

โมเดล	ผู้พัฒนา	หน้าต่างบริบท	จุดเด่นหลัก
Grok-4.20	xAI	2M tokens	การให้เหตุผลแบบหลายเอเจนต์
GPT-5.2	OpenAI	~400K tokens	การให้เหตุผลขั้นสูง + การเขียนโค้ด
Gemini 3 Pro	Google	~1M tokens	มัลติโหมดและระบบนิเวศของ Google
Claude 4 Opus	Anthropic	~200K+ tokens	การให้เหตุผลที่เชื่อถือได้

ความแตกต่างที่สำคัญ

Grok-4.20 เน้นความร่วมมือแบบหลายเอเจนต์สำหรับงานให้เหตุผล
มีหนึ่งในหน้าต่างบริบทที่ใหญ่ที่สุดใน LLM ที่อยู่ในระบบผลิตจริง (2M โทเค็น)
โมเดลคู่แข่งอาจทำได้ดีกว่า Grok ในบางด้าน เช่น การให้เหตุผลแบบมีโครงสร้างหรือการเขียนเชิงสร้างสรรค์ ขึ้นอยู่กับงานประเมิน

กรณีการใช้งานตัวอย่าง

การวิเคราะห์งานวิจัยแบบบริบทยาว
ประมวลผลเอกสารขนาดใหญ่ วัสดุกฎหมาย หรือผลงานวิชาการ
ระบบอัตโนมัติแบบเอเจนต์
สร้างเวิร์กโฟลว์หลายขั้นตอนที่โมเดลวางแผนและดำเนินงานเอง
การเขียนโค้ดและการจำลองขั้นสูง
แก้ปัญหาวิศวกรรมหรือจำลองระบบด้วยสายโซ่เหตุผลยาว
การวิเคราะห์ข้อมูลและระบบแดชบอร์ดอัตโนมัติ
ติดตามและวิเคราะห์สตรีมข้อมูลหลายชุดแบบขนาน
การประมวลผลความรู้แบบมัลติโหมด
ตีความรูปภาพ เฟรมวิดีโอ และข้อความในกระบวนการให้เหตุผลแบบรวมเดียว

วิธีการเข้าถึงและใช้งาน Grok 4.2 API

ขั้นตอนที่ 1: สมัครรับ API Key

เข้าสู่ระบบที่ cometapi.com หากคุณยังไม่เป็นผู้ใช้ของเรา โปรดลงทะเบียนก่อน เข้าสู่ คอนโซล CometAPI รับ API key สำหรับการเข้าถึงอินเทอร์เฟซ คลิก “Add Token” ที่ API token ในศูนย์ส่วนบุคคล รับ token key: sk-xxxxx และส่ง

ขั้นตอนที่ 2: ส่งคำขอไปที่ `Grok 4.2` API

เลือกเอ็นด์พอยต์ “grok-4.20-0309-reasoning” เพื่อส่งคำขอ API และกำหนด request body วิธีการร้องขอและ request body สามารถดูได้จากเอกสาร API บนเว็บไซต์ของเรา เว็บไซต์ยังมีการทดสอบ Apifox เพื่อความสะดวกของคุณ แทนที่ <YOUR_API_KEY> ด้วย CometAPI key จริงจากบัญชีของคุณ เรียกใช้จาก: Chat รูปแบบ

ใส่คำถามหรือคำขอของคุณลงในฟิลด์ content—นี่คือสิ่งที่โมเดลจะตอบกลับ ประมวลผลการตอบกลับของ API เพื่อรับคำตอบที่สร้างขึ้น

ขั้นตอนที่ 3: เรียกดูและตรวจสอบผลลัพธ์

ประมวลผลการตอบกลับ API เพื่อรับคำตอบที่สร้างขึ้น หลังจากประมวลผลแล้ว API จะตอบกลับสถานะงานและข้อมูลผลลัพธ์

ราคาสำหรับ Grok 4.20

สำรวจราคาที่แข่งขันได้สำหรับ Grok 4.20 ที่ออกแบบมาให้เหมาะสมกับงบประมาณและความต้องการการใช้งานที่หลากหลาย แผนการบริการที่ยืดหยุ่นของเรารับประกันว่าคุณจะจ่ายเฉพาะสิ่งที่คุณใช้เท่านั้น ทำให้สามารถขยายขนาดได้ง่ายเมื่อความต้องการของคุณเพิ่มขึ้น ค้นพบว่า Grok 4.20 สามารถยกระดับโปรเจกต์ของคุณได้อย่างไรในขณะที่ควบคุมต้นทุนให้อยู่ในระดับที่จัดการได้

ราคา Comet (USD / M Tokens)	ราคาทางการ (USD / M Tokens)	ส่วนลด
อินพุต:$1/M เอาต์พุต:$2/M	อินพุต:$1.25/M เอาต์พุต:$2.5/M	-20%

โค้ดตัวอย่างและ API สำหรับ Grok 4.20

เข้าถึงโค้ดตัวอย่างที่ครอบคลุมและทรัพยากร API สำหรับ Grok 4.20 เพื่อปรับปรุงกระบวนการผสานรวมของคุณ เอกสารประกอบที่มีรายละเอียดของเราให้คำแนะนำทีละขั้นตอน ช่วยให้คุณใช้ประโยชน์จากศักยภาพเต็มรูปแบบของ Grok 4.20 ในโครงการของคุณ

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

รุ่นของ Grok 4.20

เหตุผลที่ Grok 4.20 มีสแนปช็อตหลายตัวอาจรวมถึงปัจจัยที่อาจเกิดขึ้น เช่น ความแปรผันของผลลัพธ์หลังการอัปเดตที่ต้องการสแนปช็อตรุ่นเก่าสำหรับความสม่ำเสมอ การให้ช่วงเวลาเปลี่ยนผ่านสำหรับนักพัฒนาเพื่อการปรับตัวและการย้ายข้อมูล และสแนปช็อตที่แตกต่างกันซึ่งสอดคล้องกับเอนด์พอยต์ระดับโลกหรือระดับภูมิภาคเพื่อเพิ่มประสิทธิภาพประสบการณ์ผู้ใช้ สำหรับความแตกต่างโดยละเอียดระหว่างเวอร์ชัน โปรดอ้างอิงเอกสารทางการ

รหัสโมเดล	คำอธิบาย	ความพร้อมใช้งาน	การเรียกใช้งาน
grok-4.20-multi-agent-beta-0309	รุ่นมัลติเอเจนต์ที่ปรับจูนสำหรับการประสานงานเอเจนต์แบบเรียลไทม์และการเรียกใช้เครื่องมือ (เหมาะสำหรับเวิร์กโฟลว์การวิจัยเชิงลึกที่เอเจนต์ย่อยหลายตัวทำการค้นเว็บ รันโค้ด และวิจารณ์).	✅	การเรียกใช้งานแบบ response format.
grok-4.20-0309-reasoning	รุ่นที่ปรับให้เหมาะกับการให้เหตุผล: ให้ความสำคัญกับการให้เหตุผลแบบ chain-of-thought ที่ลึกขึ้น และทำคะแนน benchmark ได้สูงกว่าในแบบทดสอบที่เน้นการให้เหตุผล; คาดว่าจะมีความหน่วง/ต้นทุนต่อโทเค็นสูงกว่ารุ่นที่ไม่เน้นการให้เหตุผล.	✅	การเรียกแบบ chat format และ response format.
grok-4.20-0309-non-reasoning	รุ่นหน่วงต่ำ/ต้นทุนต่ำ สำหรับงานปริมาณสูงที่ให้ความสำคัญกับคำตอบที่กำหนดแน่นอนและสั้น หรือเอาต์พุตแบบสตรีมมิง; ข้อแลกเปลี่ยนคือคะแนน benchmark ด้านการให้เหตุผลที่ต่ำกว่า.	✅	การเรียกแบบ chat format และ response format.