มีเกณฑ์มาตรฐานใดบ้างที่แสดงประสิทธิภาพของ Grok-4.20?

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

หน้าต่างบริบทใน Grok-4.20 API มีขนาดเท่าใด?

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

Grok-4.20 มีให้ใช้ผ่าน API สำหรับนักพัฒนาหรือไม่?

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

Grok-4.20 เปรียบเทียบกับ GPT-5.2 หรือรุ่นของ Gemini อย่างไร?

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

อะไรทำให้ Grok-4.20 แตกต่างจากรุ่น Grok ก่อนหน้า?

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

Grok-4.20 สามารถจัดการอินพุตแบบหลายสื่อ เช่น รูปภาพหรือวิดีโอได้หรือไม่?

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

xAI

พร้อมใช้งาน

grok-4.20-0309-reasoning

Grok 4.20 API

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

ราคาเริ่มต้น

$1.00 / อินพุต 1 ล้านโทเคน

คิดค่าบริการตามการใช้งาน

สถานะ API

พร้อมใช้งาน

เอนด์พอยต์สำหรับโปรดักชัน

เวลาตอบสนอง

รองรับการทำงานแบบ async

เวลาตอบสนอง API ที่วัดได้จริง

วันที่เผยแพร่

Mar 11, 2026

xAI

Playground

ลองใช้ Grok 4.20 ด้วยคำขอจริง ตรวจสอบพารามิเตอร์ และตรวจสอบผลลัพธ์ก่อนเชื่อมต่อ API

ภาพรวม

ภาพรวมการใช้งานจริงของ Grok 4.20 รวมถึงพฤติกรรมสำคัญและข้อควรพิจารณาในการเชื่อมต่อ

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

รายการ	Grok-4.20 (ข้อมูลจำเพาะสาธารณะ)
ตระกูลโมเดล	ซีรีส์ Grok-4
ผู้พัฒนา	xAI
สถานะการเปิดตัว	เบต้า (ปล่อยครั้งแรก 17 ก.พ. 2026)
ประเภทอินพุต	ข้อความ, ภาพ, วิดีโอ
ประเภทเอาต์พุต	ผลลัพธ์เป็นข้อความ (รองรับเอาต์พุตแบบมีโครงสร้างและการเรียกใช้ฟังก์ชัน/เครื่องมือ).
หน้าต่างบริบท	ได้สูงสุด 2,000,000 โทเค็น
สถาปัตยกรรม	การให้เหตุผลแบบร่วมมือหลายเอเจนต์
การรองรับเครื่องมือ	การเรียกใช้ฟังก์ชัน, เอาต์พุตแบบมีโครงสร้าง
ความสามารถในการให้เหตุผล	ความสามารถในการให้เหตุผลในตัว
โครงสร้างพื้นฐานการฝึก	Colossus supercluster (~200,000 GPUs)
รุ่นย่อยของโมเดล	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 ในบางด้าน เช่น การให้เหตุผลเชิงโครงสร้างหรือการเขียนเชิงสร้างสรรค์ ขึ้นอยู่กับงานประเมิน

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

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

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

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

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

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

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

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

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

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

คำถามที่พบบ่อย

ราคา

ใช้การประเมินค่าใช้จ่ายอย่างรวดเร็วด้านบนสำหรับการรันครั้งเดียว จากนั้นดูการเปรียบเทียบราคาฉบับเต็มระหว่าง CometAPI และราคาทางการ

คำขอแรก

$0.003

ค่าใช้จ่ายโดยประมาณของ CometAPI

สิบคำขอ

$0.03

ค่าใช้จ่ายโดยประมาณของ CometAPI

สิบห้าคำขอ

$0.045

ค่าใช้จ่ายโดยประมาณของ CometAPI

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

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

Model	Comet Price (USD / M Tokens)	Official Price (USD / M Tokens)	Discount
grok-4.20-0309-reasoning	อินพุต:$1/M เอาต์พุต:$2/M	อินพุต:$1.25/M เอาต์พุต:$2.5/M	-20%

API

คัดลอกเอนด์พอยต์และตัวอย่างโค้ดที่ใช้งานได้จริง จากนั้นเปิดเอกสารอ้างอิง API ฉบับเต็มเมื่อต้องการพารามิเตอร์ทั้งหมด

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

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

POST/v1/chat/completions

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

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

POST

/v1/chat/completions

# 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

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

ความสามารถ

ตรวจสอบข้อมูลสำคัญของโมเดลก่อนเลือกสถาปัตยกรรมหรือประเมินภาระงานในโปรดักชัน

ความสามารถที่รองรับ

ฟีเจอร์ที่ส่งกลับโดย API ของโมเดลปัจจุบัน

text-to-text

image-to-text

อินพุตและเอาต์พุต

อินพุต

text

เอาต์พุต

text

โปรไฟล์การใช้งานจริง

ผู้ให้บริการ: xAI
บริบท: 2,000,000
การใช้งานเชิงพาณิชย์: รองรับ

กรณีการใช้งาน

ใช้ Grok 4.20 สำหรับเวิร์กโฟลว์ระดับโปรดักชันที่เหมาะกับความสามารถด้าน text จากนั้นเปรียบเทียบทางเลือกอื่นก่อนตัดสินใจเชื่อมต่อระยะยาว

แชทระดับโปรดักชันและเวิร์กโฟลว์ของเอเจนต์

การเขียนโค้ด วิเคราะห์ และสร้างผลลัพธ์เชิงโครงสร้าง

การทำงานอัตโนมัติปริมาณสูงผ่าน API เดียว

โมเดลอื่น ๆ

เปรียบเทียบโมเดลอื่น ๆ ที่มีให้บริการผ่าน CometAPI ในด้านคุณภาพ ความหน่วง ความสามารถ และราคา

เปิดการเปรียบเทียบโมเดล →

CometAPI

AUTO

CometAPI Auto API is an intelligent model routing feature that allows developers to access the appropriate AI model without specifying a specific model ID for each request.

ดูโมเดล

OpenAI

gpt-oss-20b(free)

สำรวจ API ของ gpt-oss-20b(free)

ดูโมเดล

Google

Gemini 3.8 Flash

Gemini 3.8 Flash เป็นโมเดล Gemini น้ำหนักเบารุ่นเจเนอเรชันใหม่ โดยมีเป้าหมายเพื่อให้เกิดความสมดุลที่ดียิ่งขึ้นระหว่างความเร็ว ต้นทุน และความสามารถด้านการเขียนโค้ด

ดูโมเดล

Anthropic

Claude Fable 5.1

ปัญญารุ่นถัดไปสำหรับเอเจนต์ที่ทำงานต่อเนื่องระยะยาว

ดูโมเดล

Z.AI

GLM 5.3 Flash

GLM-5.3-Flash เป็นโมเดลมัลติโมดัลแบบเนทีฟตัวแรกในตระกูล GLM-5 มอบความฉลาดที่ทรงพลังยิ่งกว่า GLM-5.2 พร้อมคงไว้ซึ่งสถาปัตยกรรมที่คุ้มต้นทุนเป็นพิเศษ。 GLM-5.3-Flash มีส่วนลด 50% (ราคาที่ขีดฆ่าคือราคาปกติ) โปรโมชั่นสิ้นสุดเวลา 24:00 วันที่ 9 กันยายน 2026 (UTC+8, เวลาสิงคโปร์).

ดูโมเดล

Aliyun

Qwen3.8-Flash

Qwen3.8-Flash เป็นโมเดลขนาดใหญ่แบบมัลติโมดัลรุ่นล่าสุดของ Qianwen ที่ผสานความสามารถด้านการทำความเข้าใจและการสร้างที่ทรงพลังเข้ากับความเร็วในการตอบสนองที่ยอดเยี่ยม โมเดลนี้รองรับหน้าต่างบริบทนับล้านได้โดยกำเนิด สามารถจัดการเอกสารที่ยาวเป็นพิเศษ คลังโค้ด และบทสนทนาที่ซับซ้อนได้พร้อมกัน

ดูโมเดล

Uptime

ตรวจสอบข้อมูล heartbeat แบบเรียลไทม์ ความพร้อมใช้งานของเอนด์พอยต์ และเวลาตอบสนองที่วัดได้จริงก่อนใช้งานจริง

เวอร์ชัน

ตรวจสอบตัวระบุโมเดลที่มีให้ใช้งานก่อนกำหนดเวอร์ชันสำหรับการเชื่อมต่อจริง

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

สำรวจต่อ

เปรียบเทียบโมเดลและค้นคว้าต่อ

xAI

พร้อมใช้งาน

grok-4.20-0309-reasoning

Grok 4.20 API

ราคาเริ่มต้น

$1.00 / อินพุต 1 ล้านโทเคน

คิดค่าบริการตามการใช้งาน

สถานะ API

พร้อมใช้งาน

เอนด์พอยต์สำหรับโปรดักชัน

เวลาตอบสนอง

รองรับการทำงานแบบ async

เวลาตอบสนอง API ที่วัดได้จริง

วันที่เผยแพร่

Mar 11, 2026

xAI

Playground

ภาพรวม

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

รายการ	Grok-4.20 (ข้อมูลจำเพาะสาธารณะ)
ตระกูลโมเดล	ซีรีส์ Grok-4
ผู้พัฒนา	xAI
สถานะการเปิดตัว	เบต้า (ปล่อยครั้งแรก 17 ก.พ. 2026)
ประเภทอินพุต	ข้อความ, ภาพ, วิดีโอ
ประเภทเอาต์พุต	ผลลัพธ์เป็นข้อความ (รองรับเอาต์พุตแบบมีโครงสร้างและการเรียกใช้ฟังก์ชัน/เครื่องมือ).
หน้าต่างบริบท	ได้สูงสุด 2,000,000 โทเค็น
สถาปัตยกรรม	การให้เหตุผลแบบร่วมมือหลายเอเจนต์
การรองรับเครื่องมือ	การเรียกใช้ฟังก์ชัน, เอาต์พุตแบบมีโครงสร้าง
ความสามารถในการให้เหตุผล	ความสามารถในการให้เหตุผลในตัว
โครงสร้างพื้นฐานการฝึก	Colossus supercluster (~200,000 GPUs)
รุ่นย่อยของโมเดล	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

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

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

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

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 ในบางด้าน เช่น การให้เหตุผลเชิงโครงสร้างหรือการเขียนเชิงสร้างสรรค์ ขึ้นอยู่กับงานประเมิน

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

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

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

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

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

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

คำถามที่พบบ่อย

ราคา

คำขอแรก

$0.003

ค่าใช้จ่ายโดยประมาณของ CometAPI

สิบคำขอ

$0.03

ค่าใช้จ่ายโดยประมาณของ CometAPI

สิบห้าคำขอ

$0.045

ค่าใช้จ่ายโดยประมาณของ CometAPI

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

Model	Comet Price (USD / M Tokens)	Official Price (USD / M Tokens)	Discount
grok-4.20-0309-reasoning	อินพุต:$1/M เอาต์พุต:$2/M	อินพุต:$1.25/M เอาต์พุต:$2.5/M	-20%

API

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

POST/v1/chat/completions

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

POST

/v1/chat/completions

# 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

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

ความสามารถ

ความสามารถที่รองรับ

ฟีเจอร์ที่ส่งกลับโดย API ของโมเดลปัจจุบัน

text-to-text

image-to-text

อินพุตและเอาต์พุต

อินพุต

text

เอาต์พุต

text

โปรไฟล์การใช้งานจริง

ผู้ให้บริการ: xAI
บริบท: 2,000,000
การใช้งานเชิงพาณิชย์: รองรับ

กรณีการใช้งาน

แชทระดับโปรดักชันและเวิร์กโฟลว์ของเอเจนต์

การเขียนโค้ด วิเคราะห์ และสร้างผลลัพธ์เชิงโครงสร้าง

การทำงานอัตโนมัติปริมาณสูงผ่าน API เดียว

โมเดลอื่น ๆ

เปิดการเปรียบเทียบโมเดล →

CometAPI

AUTO

CometAPI Auto API is an intelligent model routing feature that allows developers to access the appropriate AI model without specifying a specific model ID for each request.

ดูโมเดล

OpenAI

gpt-oss-20b(free)

สำรวจ API ของ gpt-oss-20b(free)

ปัญญารุ่นถัดไปสำหรับเอเจนต์ที่ทำงานต่อเนื่องระยะยาว

Uptime

เวอร์ชัน

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

สำรวจต่อ

Grok 4.20 API

Playground

ภาพรวม

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

Grok-4.20 คืออะไร

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

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

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

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

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

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

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

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

คำถามที่พบบ่อย

มีเกณฑ์มาตรฐานใดบ้างที่แสดงประสิทธิภาพของ Grok-4.20?

หน้าต่างบริบทใน Grok-4.20 API มีขนาดเท่าใด?

Grok-4.20 มีให้ใช้ผ่าน API สำหรับนักพัฒนาหรือไม่?

Grok-4.20 เปรียบเทียบกับ GPT-5.2 หรือรุ่นของ Gemini อย่างไร?

อะไรทำให้ Grok-4.20 แตกต่างจากรุ่น Grok ก่อนหน้า?

Grok-4.20 สามารถจัดการอินพุตแบบหลายสื่อ เช่น รูปภาพหรือวิดีโอได้หรือไม่?

ราคา

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

API

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

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

cURL Code Example

Python Code Example

JavaScript Code Example

ความสามารถ

กรณีการใช้งาน

โมเดลอื่น ๆ

Uptime

เวอร์ชัน

เปรียบเทียบโมเดลและค้นคว้าต่อ

Grok 4.20 API

Playground

ภาพรวม

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

Grok-4.20 คืออะไร

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

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

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

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

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

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

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

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

คำถามที่พบบ่อย

มีเกณฑ์มาตรฐานใดบ้างที่แสดงประสิทธิภาพของ Grok-4.20?

หน้าต่างบริบทใน Grok-4.20 API มีขนาดเท่าใด?

Grok-4.20 มีให้ใช้ผ่าน API สำหรับนักพัฒนาหรือไม่?

Grok-4.20 เปรียบเทียบกับ GPT-5.2 หรือรุ่นของ Gemini อย่างไร?

อะไรทำให้ Grok-4.20 แตกต่างจากรุ่น Grok ก่อนหน้า?

Grok-4.20 สามารถจัดการอินพุตแบบหลายสื่อ เช่น รูปภาพหรือวิดีโอได้หรือไม่?

ราคา

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

API

API เดียว เข้าถึงโมเดลพร้อมใช้งานจริง

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

cURL Code Example

Python Code Example

JavaScript Code Example

ความสามารถ

กรณีการใช้งาน

โมเดลอื่น ๆ

Uptime

เวอร์ชัน

เปรียบเทียบโมเดลและค้นคว้าต่อ

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

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