Claude Opus 5 is now live on CometAPI →
X

Grok 4.20

Entrada:$1/M
Saída:$2/M
Contexto:2,000,000
Lançado:Mar 11, 2026

A versão 4.20 do Grok introduz uma arquitetura multiagente (múltiplos agentes especializados coordenados em tempo real), modos de contexto expandidos e melhorias focadas em seguimento de instruções, redução de alucinações e saídas estruturadas/assistidas por ferramentas.

Novo
Uso comercial

Playground para Grok 4.20

Explore o Playground do Grok 4.20 — um ambiente interativo para testar modelos e executar consultas em tempo real. Experimente prompts, ajuste parâmetros e itere instantaneamente para acelerar o desenvolvimento e validar casos de uso.

Especificações Técnicas do Grok-4.20

ItemGrok-4.20 (especificações públicas)
Model familySérie Grok-4
DeveloperxAI
Release statusBeta (primeira disponibilização em 17 de fevereiro de 2026)
Input typesTexto, Imagem, Vídeo
Output typesSaídas de texto (suporte a saídas estruturadas e chamadas de função/ferramenta).
Context windowAté 2,000,000 tokens
ArchitectureRaciocínio colaborativo multiagente
Tool supportChamada de função, saídas estruturadas
ReasoningCapacidades de raciocínio integradas
Training infrastructureSupercluster Colossus (~200,000 GPUs)
Model variantsgrok-4.20-multi-agent-beta-0309, grok-4.20-beta-0309-reasoning, grok-4.20-beta-0309-non-reasoning.

O que é o Grok-4.20

Grok-4.20 é a versão experimental mais recente da família Grok-4 desenvolvida pela xAI. Ele foca em raciocínio orientado a agentes, manuseio de contexto extremamente longo e inferência de alta velocidade, com o objetivo de fornecer respostas precisas com uma taxa de alucinações menor do que os modelos Grok anteriores.

Ao contrário dos modelos Grok anteriores que usavam inferência de modelo único, o Grok-4.20 introduz a colaboração multiagente, em que vários agentes internos analisam um prompt simultaneamente e convergem para uma resposta final. Essa arquitetura foi projetada para melhorar o desempenho em tarefas complexas de raciocínio, programação e pesquisa.

Principais recursos do Grok-4.20

  • Janela de contexto ultralonga (2M tokens): Permite processar livros inteiros, grandes conjuntos de dados ou repositórios de código extensos em um único prompt.
  • Arquitetura de raciocínio multiagente: Até quatro agentes internos podem analisar um prompt em paralelo e debater soluções antes de produzir uma resposta final.
  • Chamadas de ferramentas orientadas a agentes e saídas estruturadas: Suporta chamadas de função e respostas estruturadas para integração com aplicativos e fluxos de trabalho automatizados.
  • Compreensão multimodal: Aceita entradas de texto, imagem e vídeo dentro do mesmo pipeline do modelo.
  • Inferência rápida com foco em baixa alucinação: a xAI posiciona o modelo como otimizado para respostas verídicas e forte adesão ao prompt.

Desempenho em benchmarks do Grok-4.20

Os dados públicos de benchmarks ainda são limitados durante a fase beta, mas relatórios iniciais indicam:

BenchmarkResultado / Status
LMSYS Chatbot ArenaELO estimado ~1505–1535
ForecastBenchClassificado em #2 nos testes iniciais
Alpha Arena trading challengeObteve +34.59% de retorno

Esses números sugerem que o Grok-4.20 compete com modelos de ponta em tarefas reais de raciocínio e orientadas a agentes, em vez de questões simples de benchmark.

Grok-4.20 Beta vs outros modelos de ponta

ModelDeveloperContext WindowKey Strength
Grok-4.20xAI2M tokensRaciocínio multiagente
GPT-5.2OpenAI~400K tokensRaciocínio avançado + programação
Gemini 3 ProGoogle~1M tokensmultimodal e ecossistema Google
Claude 4 OpusAnthropic~200K+ tokensraciocínio confiável

Principais diferenças

  • O Grok-4.20 enfatiza a colaboração multiagente para tarefas de raciocínio.
  • Oferece uma das maiores janelas de contexto entre LLMs em produção (2M tokens).
  • Modelos concorrentes podem superar o Grok em certas áreas, como raciocínio estruturado ou escrita criativa, dependendo das tarefas de avaliação.

Casos de uso representativos

  1. Análise de pesquisa com contexto longo
    Processar documentos extensos, materiais jurídicos ou pesquisas acadêmicas.
  2. Sistemas de automação orientados a agentes
    Construir fluxos de trabalho de várias etapas em que o modelo planeja e executa tarefas.
  3. Programação avançada e simulações
    Resolver problemas de engenharia ou simular sistemas com cadeias longas de raciocínio.
  4. Análise de dados e automação de dashboards
    Acompanhar e analisar múltiplos fluxos de dados em paralelo.
  5. Processamento multimodal de conhecimento
    Interpretar imagens, quadros de vídeo e texto em um processo unificado de raciocínio.

Como acessar e usar a API do Grok 4.2

Etapa 1: Cadastre-se para obter a chave de API

Faça login em cometapi.com. Se você ainda não é nosso usuário, registre-se primeiro. Acesse seu CometAPI console. Obtenha a chave de API de credenciais de acesso da interface. Clique em “Add Token” no token de API no centro pessoal, obtenha a chave do token: sk-xxxxx e envie.

Etapa 2: Envie solicitações para a API Grok 4.2

Selecione o endpoint “grok-4.20-0309-reasoning” para enviar a solicitação de API e defina o corpo da solicitação. O método e o corpo da solicitação são obtidos na documentação de API do nosso site. Nosso site também fornece teste no Apifox para sua conveniência. Substitua <YOUR_API_KEY> pela sua chave CometAPI real da sua conta. Onde chamar: formato Chat.

Insira sua pergunta ou solicitação no campo content — é a isso que o modelo responderá. Processe a resposta da API para obter a resposta gerada.

Etapa 3: Recupere e verifique os resultados

Processe a resposta da API para obter a resposta gerada. Após o processamento, a API responde com o status da tarefa e os dados de saída.

FAQ

Preços para Grok 4.20

Explore preços competitivos para Grok 4.20, projetado para atender diversos orçamentos e necessidades de uso. Nossos planos flexíveis garantem que você pague apenas pelo que usar, facilitando o dimensionamento conforme suas necessidades crescem. Descubra como Grok 4.20 pode aprimorar seus projetos mantendo os custos gerenciáveis.

ModelComet Price (USD / M Tokens)Official Price (USD / M Tokens)Discount
grok-4.20-0309-reasoning
Entrada:$1/M
Saída:$2/M
Entrada:$1.25/M
Saída:$2.5/M
-20%

Código de exemplo e API para Grok 4.20

Acesse código de exemplo abrangente e recursos de API para Grok 4.20 para otimizar seu processo de integração. Nossa documentação detalhada fornece orientação passo a passo, ajudando você a aproveitar todo o potencial do Grok 4.20 em seus projetos.

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

Versões do Grok 4.20

O motivo pelo qual Grok 4.20 possui múltiplas versões instantâneas pode incluir fatores como variações na saída após atualizações que exigem versões antigas para consistência, fornecendo aos desenvolvedores um período de transição para adaptação e migração, e diferentes versões correspondentes a endpoints globais ou regionais para otimizar a experiência do usuário. Para diferenças detalhadas entre versões, consulte a documentação oficial.

ID do modeloDescriçãoDisponibilidadeSolicitação
grok-4.20-multi-agent-beta-0309Variante multiagente ajustada para orquestração de agentes em tempo real e chamadas de ferramentas (útil para fluxos de trabalho de pesquisa aprofundada em que vários subagentes realizam pesquisas na web, execução de código e avaliação crítica).✅chamadas no formato de resposta.
grok-4.20-0309-reasoningVariante otimizada para raciocínio: prioriza um estilo de raciocínio em cadeia de pensamento mais profundo e pontuações mais altas em benchmarks de testes com forte ênfase em raciocínio; espera-se maior latência/custo por token em comparação às variantes sem raciocínio.✅chamada no formato de chat e chamadas no formato de resposta.
grok-4.20-0309-non-reasoningVariante de menor latência/menor custo para tarefas de alta taxa de transferência nas quais respostas determinísticas e curtas ou saídas em streaming são a prioridade; os trade-offs incluem pontuações mais baixas em benchmarks de raciocínio.✅chamada no formato de chat e chamadas no formato de resposta.