Grok 4.7 vs Grok 4.6: mesmo preço e mesmo contexto, onde está a diferença e como escolher

TL;DR: para codificação complexa e tarefas agentic, escolha o Grok 4.7; para tarefas leves em que se quer economizar tokens, escolha o Grok 4.6. As duas gerações têm exatamente o mesmo preço no HiAPI (entrada $0.84 / saída $2.52 por milhão de tokens) e o mesmo contexto de 500K; o único fator decisivo é o tipo de tarefa. O Grok 4.7 já está disponível no HiAPI, abra a página do modelo para testar diretamente; novos usuários ganham 200 créditos ao se registrar.

Visão rápida: onde está a diferença entre as duas gerações

Dimensão	Grok 4.7	Grok 4.6
Preço na plataforma (por milhão de tokens, entrada/saída)	$0.84 / $2.52	$0.84 / $2.52 (mesmo preço)
Contexto	500K	500K
Capacidade de codificação (Terminal-Bench 4.0, dados oficiais)	38,0%	20,3%
Posicionamento	Recomendação padrão oficial, foco em codificação e tarefas agentic	Flagship da geração anterior, ainda à venda
Consumo de tokens (terceiro traictory.com, high effort sem limite)	Cerca de 81K/tarefa, aproximadamente o dobro do 4.6	Mais baixo
Níveis de raciocínio	low / medium / high / xhigh, padrão high	O mesmo
Data de corte do conhecimento	2026-05	Mais antiga

Preço, contexto e níveis de raciocínio são idênticos; o verdadeiro divisor de águas é a capacidade de codificação e os hábitos de saída. A seguir, dois testes com o mesmo prompt falam por si.

O mesmo prompt (1): questão de codificação de cache LRU

Teste realizado em 2026-10-29 no ambiente de produção do HiAPI, com os mesmos parâmetros dos dois lados (nível de raciocínio padrão high, limite de max_tokens), uma execução para cada:

Prompt:

Escreva uma classe de cache LRU em Python, exigindo get e put em O(1), suporte a TTL (expiração automática) e segurança para threads. Forneça apenas o código e no máximo 5 linhas de instruções de uso.

Resposta do Grok 4.7 (39,7s, 3285 tokens de saída, cerca de $0.011):

class LRUCache:
    def __init__(self, capacity: int, default_ttl: Optional[float] = None):
        if capacity <= 0:
            raise ValueError("capacity must be positive")
        self.capacity = capacity
        self.default_ttl = default_ttl
        self._data: OrderedDict[Hashable, tuple[Any, Optional[float]]] = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key: Hashable, default: Any = None) -> Any:
        with self._lock:
            item = self._data.get(key)
            if item is None:
                return default
            value, expire_at = item
            if expire_at is not None and time.monotonic() >= expire_at:
                del self._data[key]
                return default
            self._data.move_to_end(key)
            return value

    def put(self, key: Hashable, value: Any, ttl: Optional[float] = None) -> None:
        with self._lock:
            ttl = self.default_ttl if ttl is None else ttl
            if ttl is not None and ttl <= 0:
                self._data.pop(key, None)
                return
            expire_at = None if ttl is None else time.monotonic() + ttl
            if key in self._data:
                self._data.move_to_end(key)
            elif len(self._data) >= self.capacity:
                self._data.popitem(last=False)
            self._data[key] = (value, expire_at)

(o texto completo inclui import e exemplo de uso; acima está o corpo principal; o 4.7 usa time.monotonic() para o TTL e permite passar um valor padrão no get.)

Resposta do Grok 4.6 (61,9s, 3915 tokens de saída, cerca de $0.012):

class LRUCache:
    def __init__(self, capacity, default_ttl=None):
        if not isinstance(capacity, int) or capacity < 1:
            raise ValueError("capacity must be positive int")
        self.capacity = capacity
        self.default_ttl = default_ttl
        self._cache = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key):
        with self._lock:
            if key not in self._cache:
                return None
            value, expire_at = self._cache[key]
            if expire_at is not None and time.time() > expire_at:
                del self._cache[key]
                return None
            self._cache.move_to_end(key)
            return value

    def put(self, key, value, ttl=None):
        with self._lock:
            now = time.time()
            expire_at = None
            effective_ttl = ttl if ttl is not None else self.default_ttl
            if effective_ttl is not None:
                expire_at = now + effective_ttl
                if expire_at <= now:
                    if key in self._cache:
                        del self._cache[key]
                    return
            if key in self._cache:
                self._cache.move_to_end(key)
            elif len(self._cache) >= self.capacity:
                self._cache.popitem(last=False)
            self._cache[key] = (value, expire_at)

Os dois códigos atendem completamente aos requisitos: OrderedDict para O(1), expiração preguiçosa de TTL e threading.Lock para segurança de threads; ambos podem ser executados diretamente.

O mesmo prompt (2): questão de raciocínio da piscina com torneiras

Uma piscina: abrindo apenas o cano de entrada, ela enche em 6 horas; abrindo apenas o cano de saída, ela esvazia em 8 horas. Agora a piscina está vazia e os dois canos são abertos ao mesmo tempo. Em quantas horas a piscina ficará exatamente cheia? Escreva o raciocínio e depois dê a resposta.

	Grok 4.7	Grok 4.6
Tempo / tokens de saída	8,3s / 573	18,5s / 637
Resposta	24 horas	24 horas

Ambos escreveram em LaTeX o processo completo de 1/6 − 1/8 = 1/24 → 1 ÷ 1/24 = 24; a conclusão e a dedução são equivalentes.

Diferenças visíveis

• Na questão de codificação, o 4.7 foi 22 segundos mais rápido (39,7s vs 61,9s) e ainda gerou uma saída mais curta (3285 vs 3915 tokens)
• Na questão de raciocínio, ambos acertaram e o processo foi equivalente
• Nos hábitos de saída, o 4.7 prefere títulos estruturados e fórmulas LaTeX, com texto mais compacto; o 4.6 também usa LaTeX, mas é um pouco mais prolixo (637 vs 573 tokens)
• Neste teste com limite (max_tokens), os tokens de saída do 4.7 não foram maiores que os do 4.6. O dado do terceiro traictory.com de «cerca de 81K tokens por tarefa, aproximadamente o dobro do 4.6» refere-se a high effort sem limite; os dois conjuntos de dados não se contradizem nem devem ser misturados
• Segundo dados oficiais, o Terminal-Bench 4.0 subiu de 20,3% para 38,0%, o que está alinhado com a percepção prática na questão de codificação acima
• Estes dois testes comparativos e mais 5 cenários executados (troubleshooting, revisão de código, design de solução, etc.), num total de 9 requisições, terminaram todos normalmente (finish=stop), sem truncamento

Como escolher por cenário

• Para codificação complexa e tarefas agentic de longa duração, escolha o Grok 4.7
• Para perguntas e respostas leves do dia a dia, conversão de formatos e scripts simples, escolha o Grok 4.6: a saída não perde qualidade e economiza tokens
• Se você já usa o 4.6 e ele é estável, não precisa migrar à força; teste primeiro o 4.7 em novas tarefas e volte quando quiser se não ficar satisfeito
• Se o orçamento é sensível mas você quer a capacidade do 4.7: as duas gerações têm o mesmo preço, a diferença está no consumo; usar o 4.6 em tarefas leves é economizar

Custo da troca: alterar apenas um campo

As duas gerações usam a mesma interface /v1/chat/completions, com parâmetros idênticos; basta mudar model de grok-4.6 para grok-4.7, e o restante do código não muda:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer $HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",  # altere aqui
        "messages": [{"role": "user", "content": "sua tarefa"}],
    },
)

Perguntas frequentes

O Grok 4.7 é mais caro que o 4.6? Não é mais caro em preço unitário: no HiAPI, as duas gerações têm o mesmo preço, entrada $0.84 / saída $2.52 por milhão de tokens. O terceiro traictory.com relata que o 4.7, em high effort sem limite, consome cerca de 81K tokens por tarefa, aproximadamente o dobro do 4.6; isso se refere ao consumo, não ao preço unitário. No nosso teste com limite de max_tokens, o 4.7 não consumiu mais que o 4.6.

Quais são as deficiências conhecidas do 4.7? Na comunidade do Cursor, alguns usuários relatam que o 4.7 ocasionalmente tem alucinações, erros de merge de código e alto consumo de tokens; alguns voltaram para o 4.6. Continuar usando o 4.6 para tarefas simples é uma alternativa segura.

Há diferença no contexto e nos níveis de raciocínio? Não. As duas gerações têm contexto de 500K e quatro níveis de raciocínio low / medium / high / xhigh, com padrão high.

Onde posso testar diretamente? Na página do modelo Grok 4.7 há teste online; novos usuários ganham 200 créditos ao se registrar. Para detalhes de preço, leia Preços da API Grok 4.7; para integração, veja o Guia da API Grok 4.7; para prompts por cenário, consulte Exemplos de prompts do Grok 4.7; quem ainda usa a versão antiga pode comparar com a página do modelo Grok 4.6.