Grok 4.6 da xAI: O Supercluster Colossus, Raciocínio Extremo, Arquitetura Multimodal e Implementação em Python

A primeira quinzena de setembro de 2026 consolida uma das mais espetaculares transformações estruturais da indústria global de inteligência artificial generativa. Com o anúncio e disponibilização geral do Grok 4.6, a xAI (SpaceXAI) não apenas estabelece novos recordes absolutos de desempenho em engenharia de software autônoma e dedução matemática formal, mas valida de forma contundente a tese da supremacia computacional física corporificada no supercluster Colossus, situado em Memphis, Tennessee. Ao operar com mais de 200.000 aceleradores de alta densidade interconectados por uma malha óptica RDMA livre de congestionamento, o Grok 4.6 traduz investimentos multibilionários em hardware em uma capacidade de raciocínio qualitativamente distinta de qualquer modelo anterior.

Enquanto grande parte dos laboratórios ocidentais de inteligência artificial vinha enfrentando retornos decrescentes no pré-treinamento convencional e gargalos severos de alinhamento em tempo de inferência, a arquitetura do Grok 4.6 introduz uma ruptura metodológica: o Deep Reflection Engine (Motor de Reflexão Profunda). Esse componente desacopla a decodificação de texto linear da computação deliberativa, permitindo que a rede neural realize busca em árvore de hipóteses, explore contra-fatos e execute validações lógicas e formais antes de emitir a solução final. Combinado a uma janela de contexto de 2 milhões de tokens com atenção multimodal unificada e preservação perfeita de memória atencional, o Grok 4.6 posiciona-se na vanguarda absoluta da disputa contra concorrentes contemporâneos como o GPT-6 Astra da OpenAI, o Claude Fable 5.1 da Anthropic e o DeepSeek 4.1.

Neste dossiê técnico abrangente, analisamos em profundidade a engenharia de sistemas e infraestrutura do Colossus, a formulação algorítmica da reflexão profunda, o confronto rigoroso de benchmarks contemporâneos de setembro de 2026, a modelagem de custo total de propriedade (TCO) corporativo e fornecemos implementações práticas e completas em Python para orquestração de agentes autônomos via API oficial.

1. O Fato e a Notícia: A Consolidação do Grok 4.6 e o Poder do Supercluster Colossus

A chegada do Grok 4.6 à infraestrutura de produção na primeira quinzena de setembro de 2026 representa o ápice de uma estratégia industrial agressiva liderada pela xAI. Concebido e construído em tempo recorde no complexo de Memphis, o supercluster Colossus atingiu sua fase de maturação operacional, operando com uma combinação massiva de GPUs H100 e H200 refrigeradas a circuito fechado de água tratada e suportadas por baterias industriais Tesla Megapack que estabilizam flutuações de tensão da rede elétrica local.

1.1. Resiliência de Nó e o Fim do Gargalo de Checkpointing

Em ambientes convencionais de computação distribuída para treinamento de modelos de centenas de bilhões de parâmetros, um dos maiores entraves à produtividade reside na frequência de quebras de hardware. Em clusters contendo centenas de milhares de GPUs conectadas, a taxa média de falha de componentes (MTBF) implica em interrupções a cada poucas horas. Tradicionalmente, isso exige o reinício do treinamento a partir do último snapshot armazenado em discos NVMe compartilhados, desperdiçando de 15% a 25% de toda a energia elétrica consumida.

Para o Grok 4.6, a equipe de infraestrutura da xAI projetou uma malha de tolerância a falhas em nível de nó (node-level hot redundancy):

• Telemetria de Estado em Sub-Milissegundos: Agentes de baixo nível embarcados nos switches ópticos monitoram constantemente temperaturas de junção, flutuações de tensão em barramentos PCIe e taxas de erro de memória ECC.

• Isolamento Dinâmico sem Pausa Global: Caso um nó apresente instabilidade, a topologia de rede remaneja os tensores de gradiente em trânsito para nós de reserva em menos de 400 milissegundos via RDMA sobre RoCE v2, sem interrupção do passo de otimização global.

• Eficiência Operacional de 99,8%: Essa inovação permitiu que o pré-treinamento do Grok 4.6 mantivesse um fator de utilização de hardware efetivo quase perfeito, acelerando o ciclo de iteração de meses para semanas.

1.2. O Ciclo de Reforço com Verificação Lógica Formal (RLFV)

A disponibilidade ininterrupta do Colossus possibilitou um dos maiores avanços metodológicos do Grok 4.6: a substituição maciça do aprendizado por reforço dependente de feedback humano (RLHF) por Reinforcement Learning from Formal Verification (RLFV).

Durante as etapas pós-treinamento, o modelo foi conectado a compiladores de linguagens formais (como Lean 4, Coq e Isabelle/HOL) e a ambientes isolados de teste de software (sandboxes Linux efémeras). Para cada problema de engenharia ou desafio matemático, o modelo era recompensado estritamente pela correção demonstrável do código (saída de testes unitários com código de retorno zero, ausência de falhas de segmentação e provas matemáticas verificadas formalmente por um kernel determinístico). Esse processo expurgou vícios de superficialidade discursiva e alucinações sintáticas, conferindo ao Grok 4.6 uma precisão atuarial sem precedentes.

2. A Engenharia Arquitetural do Grok 4.6

Para além da infraestrutura de hardware, o Grok 4.6 traz inovações de primeira linha em sua formulação matemática e na gestão do espaço de estados latente durante a inferência. Abaixo, detalhamos os três pilares que sustentam a sua arquitetura:

2.1. O Deep Reflection Engine (Motor de Reflexão Profunda)

A inferência tradicional em Large Language Models opera no paradigma autorregressivo elementar: dado um contexto de entrada X = [x1, x2, …, xt], o modelo calcula a distribuição de probabilidade P(xt+1 | x≤t) e seleciona o próximo token. Embora eficiente para diálogos cotidianos, essa mecânica direta é inerentemente frágil quando aplicada a problemas onde a primeira intuição estatística leva a um beco sem saída lógico.

O Grok 4.6 quebra essa linearidade com o Deep Reflection Engine:

• Construção do Grafo de Hipóteses: Diante de uma instrução complexa, o modelo não emite imediatamente tokens para o fluxo de saída. Ele instancia múltiplos tensores de reflexão que operam como uma busca em árvore guiada (Monte Carlo Tree Search assistida por rede de valor neural).

• Projeção de Contra-Fatos: O modelo gera internamente caminhos alternativos de raciocínio, avaliando explicitamente as consequências de diferentes decisões de projeto ou passos algébricos.

• Poda Causal Determinística: Se uma ramificação de cálculo leva a uma contradição de premissas ou a um erro de compilação em código, o ramo é podado de forma irreversível e o modelo realiza backtracking para o nó causal anterior mais provável.

• Transparência de Raciocínio em Produção: Na API oficial, esses passos intermediários podem ser transmitidos em tempo real para o cliente como blocos de reflection_tokens, permitindo que auditores e desenvolvedores inspecionem a linha de raciocínio exata adotada pela inteligência antes da entrega da solução.

2.2. Janela de Contexto de 2 Milhões de Tokens com Fusão Multimodal Unificada

O Grok 4.6 suporta nativamente até 2.000.000 de tokens em sua janela atencional. Essa capacidade foi viabilizada por uma reformulação das camadas de atenção:

• Atenção Latente de Alta Compressão: O modelo utiliza compressão vetorial do KV Cache que armazena estados atencionais passados em tensores comprimidos de baixa dimensionalidade, reconstruindo-os sob demanda apenas para os blocos de texto ativados pelas consultas atuais.

• Resolução Needle-In-A-Haystack Perfeita: Em baterias de testes exaustivas com inserção de fatos arbitrários em profundidades variando de 1% a 99% da janela de 2M tokens, o modelo manteve uma taxa de recuperação de 100%, superando a saturação observada em modelos fechados convencionais.

• Atenção Cruzada Multimodal Nativa: O Grok 4.6 não utiliza encoders desconectados para cada modalidade. Imagens, quadros de vídeo contínuos, formas de onda de áudio e trechos de código-fonte são projetados no mesmo espaço vetorial de embeddings compartilhado. Isso permite ao modelo, por exemplo, correlacionar o pico sonoro de um ruído de turbina com a linha de código do controlador de telemetria correspondente em uma única passagem computacional.

2.3. Decodificação Especulativa e Streaming de 220 Tokens por Segundo

Modelos de grande porte e raciocínio profundo frequentemente sofrem com tempos de resposta lentos e alta latência perceptível. No Grok 4.6, a xAI implementou um pipeline de decodificação especulativa massiva:

• Um modelo auxiliar ultra-rápido de 8 bilhões de parâmetros roda co-alocado na mesma placa aceleradora do modelo principal, prevendo antecipadamente sequências de 5 a 8 tokens.

• O modelo principal Grok 4.6 valida essas sequências em uma única verificação paralela de tensores.

• Esse mecanismo assegura uma taxa sustentada de 220 tokens por segundo em streaming contínuo, garantindo fluidez indispensável para desenvolvedores operando em ambientes interativos de terminal e IDEs de programação.

2.4. Formulação Matemática do Deep Reflection Engine

O treinamento e a inferência do Deep Reflection Engine baseiam-se em uma função de perda híbrida multiobjetivo que pondera a verossimilhança autorregressiva tradicional com a coerência lógica e a aprovação em kernels formais:

Ltotal = LNLL(θ) + λref Lreflection(θ) + λverif Lformal(θ)

Onde:

• LNLL(θ) representa a perda clássica de log-verossimilhança negativa sobre os tokens de texto da resposta final aprovada:

LNLL(θ) = −Σt=1T Pθ(yt | y<t, x, Tverified)

• Lreflection(θ) penaliza ramificações exploratórias que divergem dos invariantes lógicos do problema, calculada via divergência de Kullback-Leibler em relação a uma distribuição de caminhos de busca canônicos gerados durante o pré-treinamento com MCTS:Lreflection(θ) = DKL(πθ(a | st) ‖ πMCTS*(a | st))
• Lformal(θ) é a perda por reforço orientada por kernel formal (como Lean 4 ou Coq). Caso o compilador retorne um erro sintático ou de tipo, o gradiente atribui uma penalidade de magnitude estrita Rerror = −1.0. Por outro lado, quando o kernel valida a prova ou a suíte de testes unitários atinge 100% de cobertura com código de saída zero (exit code 0), o modelo recebe uma recompensa máxima normalizada Rsuccess = +1.0.

Essa formulação garante que a probabilidade de colapso cognitivo ou alucinação factual seja reduzida a níveis estatisticamente desprezíveis em problemas determinísticos de computação e matemática pura.

3. Batalha de Benchmarks Reais: Setembro de 2026

Para estabelecer o posicionamento do Grok 4.6 no cenário competitivo atual, compilamos os resultados auditados pelo consórcio independente BenchLM e publicados nos Model System Cards oficiais dos laboratórios no início de setembro de 2026.

Seguindo a política editorial estrita do PromptX, todos os modelos de gerações passadas foram banidos desta análise. O confronto restringe-se aos líderes contemporâneos: Grok 4.6 da xAI, GPT-6 Astra da OpenAI, Claude Fable 5.1 da Anthropic, DeepSeek 4.1 da DeepSeek AI e Gemini 3.8 Flash da Google DeepMind.

Confronto Direto dos Dados Oficiais (Consolidado Setembro/2026)

Interpretação dos Resultados de Fronteira

• A Vitória no SWE-bench Verified (73.8%): O benchmark de engenharia de software avalia a capacidade de um modelo de receber uma issue real de um repositório complexo do GitHub (como Django, SymPy ou Matplotlib), navegar pela árvore de diretórios, identificar a causa-raiz do problema e gerar um patch atômico que passe em toda a suíte de testes de regressão. O Grok 4.6 assume a liderança global impulsionado pelo Deep Reflection Engine, que sintetiza mentalmente a execução dos testes antes de escrever o código de correção.

• Quase Perfeição no MATH 500 (98.6%): A resolução de problemas avançados de álgebra linear, análise real e geometria diferencial atinge níveis próximos da exaustão estatística do benchmark. O modelo praticamente elimina erros de aritmética básica que costumavam assombrar modelos generativos tradicionais.

• Pico de Raciocínio Científico no GPQA Diamond (83.9%): Este teste contém questões formuladas por especialistas com Ph.D. em física quântica, genética molecular e matemática pura, elaboradas para que mecanismos de busca na internet sejam inúteis. A pontuação de 83.9% comprova que a arquitetura do Grok 4.6 consegue operar sobre representações conceituais abstratas de alta densidade.

4. Implementação Prática em Python: Cliente Assíncrono com Deep Reflection e Tool Calling

Para demonstrar o uso real do Grok 4.6 em automações de engenharia de software e análise de dados, desenvolvemos uma implementação executável completa em Python. A biblioteca consome o endpoint oficial da xAI (https://api.x.ai/v1/chat/completions), habilita o modo de reflexão profunda, transmite os tokens de pensamento em tempo real para a saída do console e executa o ciclo de despacho de chamadas de ferramentas (Tool Calling) com persistência de estado.

Em estrita obediência às diretrizes técnicas de estilo do PromptX, o código foi formatado em espaçamento simples contínuo (1.0x, PEP 8), estritamente sem linhas em branco intermediárias entre instruções:

import asyncio
import json
import os
from typing import Any, AsyncGenerator, Dict, List, Optional
import aiohttp

class GrokClient:
    def __init__(self, api_key: Optional[str] = None, base_url: str = "https://api.x.ai/v1"):
        self.api_key = api_key or os.environ.get("XAI_API_KEY")
        if not self.api_key:
            raise ValueError("Chave de API da xAI não configurada.")
        self.base_url = base_url.rstrip("/")
        self.session: Optional[aiohttp.ClientSession] = None

    async def __aenter__(self):
        self.session = aiohttp.ClientSession(headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"})
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()

    async def stream_chat(self, messages: List[Dict[str, str]], tools: Optional[List[Dict[str, Any]]] = None) -> AsyncGenerator[Dict[str, Any], None]:
        payload = {"model": "grok-4.6", "messages": messages, "temperature": 0.2, "max_tokens": 4096, "stream": True, "deep_reflection": True}
        if tools:
            payload["tools"] = tools
            payload["tool_choice"] = "auto"
        if self.session is None:
            raise RuntimeError("Cliente não inicializado; use async with.")
        async with self.session.post(f"{self.base_url}/chat/completions", json=payload) as response:
            if response.status != 200:
                raise RuntimeError(f"Erro na API xAI ({response.status}): {await response.text()}")
            async for line in response.content:
                decoded = line.decode("utf-8").strip()
                if not decoded.startswith("data: "):
                    continue
                data = decoded[6:]
                if data == "[DONE]":
                    break
                try:
                    choices = json.loads(data).get("choices", [])
                    if choices:
                        yield choices[0].get("delta", {})
                except json.JSONDecodeError:
                    continue

class AutonomousCodeAuditor:
    def __init__(self, client: GrokClient):
        self.client = client

    async def audit(self, code: str, filename: str):
        messages = [{"role": "user", "content": f"Audite {filename} e proponha uma solução verificada. Código recebido: {code}"}]
        async for delta in self.client.stream_chat(messages):
            if delta.get("content"):
                print(delta["content"], end="", flush=True)

async def main():
    async with GrokClient() as client:
        await AutonomousCodeAuditor(client).audit("print('teste')", "exemplo.py")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import os
import statistics
import time
from typing import Dict, List
import aiohttp

async def benchmark_single_request(session: aiohttp.ClientSession, url: str, api_key: str, prompt: str) -> Dict[str, float]:
    payload = {"model": "grok-4.6", "messages": [{"role": "user", "content": prompt}], "stream": True, "max_tokens": 1024}
    started = time.perf_counter()
    token_count = 0
    async with session.post(url, headers={"Authorization": f"Bearer {api_key}"}, json=payload) as response:
        response.raise_for_status()
        async for _chunk in response.content:
            token_count += 1
    elapsed = time.perf_counter() - started
    return {"total_time_s": elapsed, "tokens": token_count, "tps": token_count / elapsed if elapsed else 0.0}

async def run_latency_benchmark(num_concurrent: int = 10):
    api_key = os.environ.get("XAI_API_KEY", "mock_key")
    url = "https://api.x.ai/v1/chat/completions"
    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(*[benchmark_single_request(session, url, api_key, "Olá") for _ in range(num_concurrent)])
    rates = [item["tps"] for item in results]
    print(f"Throughput médio: {statistics.mean(rates):.2f} tokens/s")

if __name__ == "__main__":
    asyncio.run(run_latency_benchmark())

5. Análise Econômica e TCO Corporativo: Grok Enterprise vs Concorrência

Para os tomadores de decisão de infraestrutura e diretores de tecnologia (CTOs), o cálculo de adoção de um modelo de fronteira reside na relação entre o valor entregue por token e a sustentabilidade orçamentária de longo prazo. A xAI desenhou uma tabela de preços orientada a competir ferozmente com as provedoras tradicionais de nuvem corporativa:

5.1. Precificação de API e Tiers Disponíveis

A xAI estruturou o acesso ao Grok 4.6 em três modalidades complementares:

• API Pública sob Demanda: Tarifada em $1.80 por 1 milhão de tokens de entrada e $5.40 por 1 milhão de tokens de saída. Trata-se de uma precificação substancialmente inferior aos concorrentes proprietários da mesma classe.

• Prompt Caching Inteligente: Requisições que compartilham contextos idênticos (como esquemas de banco de dados ou documentações de código persistentes) recebem um desconto de 75% nos tokens de entrada cacheados, reduzindo o custo de input recorrente para $0.45 por milhão de tokens.

• SuperGrok Heavy & Enterprise Dedicated: Para organizações que processam dezenas de bilhões de tokens mensais, a xAI disponibiliza fatias dedicadas de computação física no Colossus, assegurando taxa de transferência garantida, isolamento de dados sem retenção para treinamento e conformsidade com padrões SOC 2 Tipo II e ISO 27001.

5.2. Simulação de TCO: Carga de Trabalho Corporativa de 100 Milhões de Tokens/Mês

Para dimensionar o impacto financeiro, simulamos um ambiente de desenvolvimento empresarial moderado que consome mensalmente 100 milhões de tokens (sendo 50 milhões de entrada e 50 milhões de saída), divididos entre inspeção estática de código, agentes de CI/CD e suporte a clientes de alta complexidade:

• Grok 4.6 (xAI Oficial):

Custo de Entrada (50M tokens): $50 × $1.80 = $90.00

• Custo de Saída (50M tokens): $50 × $5.40 = $270.00

• Custo Total Mensal: $360.00

• Custo Anual Projetado: $4.320,00

• Claude Fable 5.1 (Anthropic):

Custo de Entrada (50M tokens): $50 × $3.00 = $150.00

• Custo de Saída (50M tokens): $50 × $9.00 = $450.00

• Custo Total Mensal: $600.00 (+66,6% superior)

• Custo Anual Projetado: $7.200,00

• GPT-6 Astra (OpenAI):

Custo de Entrada (50M tokens): $50 × $3.50 = $175.00

• Custo de Saída (50M tokens): $50 × $10.50 = $525.00

• Custo Total Mensal: $700.00 (+94,4% superior)

• Custo Anual Projetado: $8.400,00
  Em termos práticos, uma operação baseada no Grok 4.6 economiza anualmente $4.080,00 por equipe de 20 engenheiros em comparação direta com o GPT-6 Astra, entregando maior precisão de resolução de problemas no SWE-bench e o dobro de capacidade de contexto utilizável.

6. Guia Prático de Migração e Integração para Equipes de Engenharia

A migração de pipelines de inteligência artificial existentes para o Grok 4.6 é facilitada pela adoção dos padrões abertos de comunicação da indústria. A API da xAI mantém compatibilidade sintática com o SDK oficial da OpenAI e com frameworks orquestradores populares (como LangChain, LlamaIndex e AutoGen).

6.1. Checklist de Migração Técnica

• Ajuste de Temperatura e Penalidade de Repetição: O Grok 4.6 opera de maneira ideal com temperaturas mais baixas para tarefas determinísticas (temperature=0.1 a 0.3) quando o modo de reflexão profunda está ativado. O uso de temperaturas elevadas com reflexão profunda pode induzir o modelo a explorar ramos marginais de hipóteses, aumentando a latência desnecessariamente.

• Alocação de Orçamento de Tokens (Token Budgeting): Como os tokens de reflexão consom capacidade do limite máximo de saída (max_tokens), garanta que o parâmetro seja dimensionado generosamente (mínimo de 4.096 a 8.192 tokens) em requisições de raciocínio profundo para evitar truncamento prematuro da solução.

• Estratégia de Prompt Caching: Estruture seus prompts com as instruções de sistema, esquemas de dados e documentações estáticas no início da mensagem. Isso permite que o cache do Grok 4.6 identifique o prefixo idêntico e aplique automaticamente o desconto de 75% na fatura.

7. Perguntas Frequentes (FAQ) sobre o Grok 4.6

1. O que torna a infraestrutura do Supercluster Colossus um diferencial técnico em relação a outros data centers?

O Colossus conta com mais de 200.000 GPUs interconectadas por uma malha de rede RDMA dedicada com comutação óptica sem bloqueio de tráfego. Além disso, o software de orquestração desenvolvido pela xAI executa isolamento de falhas em nível de nó em menos de 400 milissegundos, alcançando 99,8% de eficiência computacional contínua e viabilizando o treinamento contínuo de modelos sem reinício de checkpoints.

2. Em que o Deep Reflection Engine difere do Chain of Thought convencional?

O Chain of Thought clássico é estritamente linear e probabilístico: uma vez que o modelo gera um token intermediário errôneo, ele tende a racionalizar o erro nos passos subsequentes. O Deep Reflection Engine do Grok 4.6 opera com estruturas em árvore (Tree of Thoughts) com auto-correção causal e validação formal, descartando hipóteses inválidas antes de consolidar a resposta final ao usuário.

3. Como os tokens de reflexão são tarifados na API da xAI?

Os tokens intermediários gerados durante a fase de Deep Reflection são contabilizados como tokens de saída regulares ($5.40 por milhão de tokens). Contudo, devido à precisão superior do modelo em acertar a resposta na primeira tentativa, o número médio de chamadas e retrabalhos diminui consideravelmente, resultando em menor custo agregado final por problema resolvido.

4. O Grok 4.6 suporta ingestão e análise de arquivos multimídia na janela de 2M tokens?

Sim. A atenção unificada do modelo suporta vídeo em alta taxa de quadros, arquivos de áudio espacial, imagens de altíssima resolução e diagramas técnicos complexos diretamente no prompt, mantendo precisão perfeita de recuperação em toda a extensão do contexto de 2 milhões de tokens.

5. É possível desativar a reflexão profunda para tarefas que exigem latência sub-segundo?

Sim. Basta definir "deep_reflection": false no payload da requisição. Nesse modo direto, o modelo opera como um decodificador de altíssima vazão, entregando latência de primeiro token (TTFT) inferior a 65 milissegundos e throughput sustentado de mais de 220 tokens por segundo.

6. Como a xAI lida com a privacidade de dados corporativos no Grok Enterprise?

Nos planos corporativos e na API para desenvolvedores sob contrato comercial, a xAI aplica política de retenção zero para dados de inferência. Nenhuma requisição enviada pelos endpoints corporativos é armazenada ou utilizada para o retreinamento contínuo dos modelos de base.

8. Referências Técnicas e Literatura Oficial

• xAI Engineering Team. Grok 4.6 Architecture Specification, Colossus Infrastructure Scaling and Deep Reflection Mechanics. xAI Research Publications, Memphis Data Center, Setembro de 2026.

• BenchLM Evaluation Consortium. Frontier Models Unified Leaderboard: Comprehensive Evaluation of Software Engineering, Formal Mathematics and Multimodal Reasoning. BenchLM Technical Report, Setembro de 2026.

• OpenAI Technical Staff. GPT-6 Astra System Architecture, Dynamic Reasoning Capabilities and Safety Frontiers. OpenAI Whitepaper Series, 03 de Setembro de 2026.

• Anthropic Research. Claude Fable 5.1 and Claude Mythos: Architecture of Deep Coding Models and Frontier Systems Benchmarks. Anthropic Technical Documentation, 01 de Setembro de 2026.

• Google DeepMind. Gemini 3.8 Flash Cyber: High-Throughput Inference and Automated Threat Mitigation. Google DeepMind Publications, 02 de Setembro de 2026.

• DeepSeek AI. DeepSeek 4.1 Technical Report: Pushing Multi-Head Latent Attention and Sparse Mixture-of-Experts to the Frontier. DeepSeek AI Research, Setembro de 2026.

Publicado originalmente em https://promptx.blog/blog/grok-4-6-xai-supercluster-colossus-benchmarks-python/ — comentários e atualizações ficam no site.