44% no ARC-AGI-1 por 67 Centavos: O Transformer Treinado do Zero em 1h30 Numa Única RTX 5090
Olá HaWkers, em 1º de setembro de 2026 um post chamado "44% on ARC-AGI-1 in 67 cents" subiu ao topo do Hacker News e fechou o dia com 621 pontos e 158 comentários. O autor, Mithil Vakde, formado em Engenharia Física pelo IIT Bombay em 2023, treinou um transformer comum de 75 milhões de parâmetros do zero, em cerca de 1h30, numa única RTX 5090 alugada, e marcou 44% no conjunto público de avaliação do ARC-AGI-1. O custo total de computação foi de 67 centavos de dólar. O mesmo modelo faz 7% no ARC-AGI-2.
Você acha que só quem tem cluster de GPU consegue fazer pesquisa relevante em inteligência artificial? Neste artigo eu mostro o que é o ARC-AGI e por que ele resiste aos LLMs, qual foi a receita técnica do Vakde, como funciona o treino em tempo de teste que sustenta o resultado, onde esse número se encaixa na tabela ao lado de TRM, HRM, o3 e Gemini 3.1 Pro, e como reproduzir tudo pelo preço de um café.
O Que É o ARC-AGI e Por Que Ele Resiste aos LLMs
O ARC, sigla de Abstraction and Reasoning Corpus, foi criado por François Chollet em 2019 no artigo "On the Measure of Intelligence". Cada tarefa é um quebra-cabeça visual: você recebe dois ou três pares de grades coloridas, entrada e saída, e precisa descobrir a regra de transformação para aplicá-la numa grade nova. As grades têm no máximo 30 por 30 células e dez cores. Um humano resolve a maioria delas em minutos, sem nenhum treino.
A graça do benchmark é que cada tarefa tem uma regra própria. Não existe padrão para decorar, e é exatamente por isso que os modelos de linguagem, treinados para reproduzir padrões vistos na internet, sofreram tanto tempo com ele. O ARC Prize, lançado em junho de 2024 com mais de 1 milhão de dólares em prêmios, transformou o conjunto de dados numa competição pública.
O ponto de virada veio em dezembro de 2024, quando a OpenAI apresentou o o3: 75,7% no conjunto semi-privado do ARC-AGI-1 com cerca de 20 dólares por tarefa, e 87,5% na configuração de alta computação, com custo estimado na casa de milhares de dólares por tarefa. Eu contei essa história em detalhes no post sobre o o3 e a nova era dos modelos de raciocínio. Resolver o ARC-AGI-1 deixou de ser a pergunta. A pergunta passou a ser: a que custo?
É nesse contexto que 67 centavos vira um número interessante.
O Que Mithil Vakde Fez em 1h30
A ideia central do mdlARC, nome do repositório, é simples de descrever e difícil de executar bem. Cada par entrada-saída de uma tarefa vira uma sequência de tokens. Um transformer pequeno é treinado do zero, de forma autorregressiva, nessas sequências, e o treino acontece em tempo de teste: o modelo vê os exemplos de treino e as entradas das tarefas de avaliação, nunca as respostas, e aprende tudo durante a própria prova.
O README do repositório resume a conta: 75 milhões de parâmetros, um transformer padrão, cerca de 2 horas numa RTX 5090 alugada na vast.ai e custo total aproximado de 0,67 dólar. A versão anterior do mesmo projeto marcava 27,5% gastando 1,80 dólar em menos de 3 horas numa A100 do Google Colab. O salto para 44% veio de uma lista de mudanças que qualquer pessoa que treina modelos hoje reconhece:
- Arquitetura moderna: SwiGLU no lugar de GELU, RMSNorm no lugar de LayerNorm.
- Escala modesta: 8 camadas em vez de 4.
- Embeddings posicionais 3D com RoPE, para o modelo entender linha, coluna e posição dentro do par.
- Embeddings aditivos por tarefa, que deixam o aprendizado atravessar tarefas diferentes.
- Otimizador NorMuon no lugar do AdamW.
- Flash attention com treino de comprimento variável e kernels do flex attention.
- Supervisão só na saída: o modelo aprende a prever apenas a grade de resposta, não a de entrada.
- Menos aumentações de dados, o que derrubou o custo e, segundo o autor, melhorou a eficiência amostral.
Os dados de treino misturam o ARC-AGI-1, as tarefas do ARC-AGI-2 que não se sobrepõem ao primeiro e o ConceptARC. As aumentações são permutações de cor e as oito simetrias diedrais, rotações e espelhamentos. No fim, o modelo gera várias respostas para cada tarefa e submete as duas mais frequentes, que é o limite de tentativas que o ARC permite.
A Receita Técnica: A Grade Vira Sequência de Tokens
Para entender por que um transformer de texto consegue resolver um quebra-cabeça visual, vale olhar a tokenização. Cada célula vira um token de 0 a 9, que é a cor. Dois tokens extras marcam o fim da linha e o fim da grade, para o modelo saber onde a geometria termina.
# Cada célula da grade vira um token de 0 a 9 (a cor).
# Dois separadores marcam fim de linha e fim de grade, como no mdlARC.
NOVA_LINHA = 10
FIM_GRADE = 11
def grade_para_tokens(grade: list[list[int]]) -> list[int]:
"""Achata uma grade ARC em uma sequência 1D de tokens."""
tokens = []
for linha in grade:
tokens.extend(linha) # cores 0-9
tokens.append(NOVA_LINHA) # quebra de linha explícita
tokens.append(FIM_GRADE) # sinal de fim para o modelo
return tokens
def par_para_sequencia(entrada, saida):
"""Concatena entrada e saída: o modelo só é supervisionado na saída."""
return grade_para_tokens(entrada) + grade_para_tokens(saida)
exemplo = par_para_sequencia([[0, 1], [1, 0]], [[1, 0], [0, 1]])
print(exemplo)
# [0, 1, 10, 1, 0, 10, 11, 1, 0, 10, 0, 1, 10, 11]Repare que a saída não é uma imagem, é uma sequência. Isso permite reaproveitar tudo o que a indústria construiu para modelos de linguagem, de flash attention a RoPE, num problema que não tem nada de linguagem. Foi um dos debates mais longos da thread do Hacker News: um transformer autorregressivo treinado em grades é um LLM? A resposta do autor foi que sequência de tokens não precisa ser sequência de palavras.
Treino em Tempo de Teste Não É Trapaça?
Essa foi a pergunta mais repetida na discussão, e ela merece uma resposta técnica. O modelo é treinado nas entradas das tarefas de avaliação, mas nunca vê as saídas. A analogia do autor: você nasce durante a prova, recebe um conjunto de treino e aprende tudo do zero enquanto a prova acontece. É aprendizado transdutivo, e é a mesma família de técnica que venceu o ARC Prize em 2024 e 2025.
Aliás, test-time training é primo do test-time compute que eu expliquei no post sobre como o o3 escala raciocínio em tempo de inferência. A diferença é que, em vez de gastar mais tokens pensando, o modelo gasta gradientes aprendendo com os exemplos da tarefa.
O mecanismo que faz isso funcionar sem vazamento são as aumentações. Como cada tarefa tem só dois ou três exemplos, o treino multiplica esses exemplos aplicando transformações que preservam a regra: girar a grade, espelhar, trocar as cores entre si. Se a regra é "pinte de azul a maior forma", ela continua válida depois de uma rotação de 90 graus com as cores permutadas.
import random
import numpy as np
def aumentar(grade: np.ndarray, semente: int) -> np.ndarray:
"""Gera uma variação da grade que preserva a regra da tarefa."""
rng = random.Random(semente)
g = grade.copy()
# 1) Simetria diedral: uma das 8 combinações de rotação e espelho
g = np.rot90(g, k=rng.randint(0, 3))
if rng.random() < 0.5:
g = np.fliplr(g)
# 2) Permutação de cores: embaralha as cores 1-9 e mantém o fundo 0
cores = list(range(1, 10))
rng.shuffle(cores)
mapa = {0: 0, **{original: nova for original, nova in zip(range(1, 10), cores)}}
return np.vectorize(mapa.get)(g)
original = np.array([[0, 1, 2], [3, 0, 4]])
print(aumentar(original, semente=42))A mesma permutação precisa ser aplicada à entrada e à saída do mesmo par, senão a regra quebra. Na hora de responder, o processo é invertido: o modelo gera a saída sob cada aumentação, o código desfaz a transformação e as respostas que mais se repetem ganham. É uma votação, e ela é a razão de o modelo submeter as duas grades mais frequentes:
from collections import Counter
def votar_duas_respostas(candidatos: list[tuple]) -> list[tuple]:
"""Recebe as saídas geradas sob várias aumentações, já desfeitas
para a orientação original, e devolve as 2 mais frequentes.
O ARC aceita 2 tentativas por tarefa."""
contagem = Counter(candidatos)
return [grade for grade, _ in contagem.most_common(2)]
# Cada candidato é a grade como tupla de tuplas, para poder entrar no Counter
candidatos = [
((1, 0), (0, 1)),
((1, 0), (0, 1)),
((0, 1), (1, 0)),
((1, 0), (0, 1)),
((1, 1), (0, 0)),
]
print(votar_duas_respostas(candidatos))
# [((1, 0), (0, 1)), ((0, 1), (1, 0))]Sobre a suspeita de que o conjunto público seja mais fácil que o privado, o autor respondeu na thread que o mesmo método o colocou em décimo lugar no conjunto privado do Kaggle. Não é o mesmo que um resultado verificado pela ARC Prize, e vale dizer isso com clareza, mas é um sinal de que o número não é artefato de vazamento.
Onde Isso Fica na Tabela: TRM, HRM, NVARC e Gemini 3.1 Pro
O resultado empata com dois modelos que viraram assunto em 2025 e que dependem de recursão para raciocinar. O HRM, Hierarchical Reasoning Model, tem 27 milhões de parâmetros e marcou 40,3% no ARC-AGI-1. O TRM, Tiny Recursive Model, do laboratório Samsung SAIL de Montreal, anunciou 7 milhões de parâmetros com 45% no ARC-AGI-1 e 8% no ARC-AGI-2. Vakde faz uma ressalva interessante sobre o TRM: o modelo é anunciado como 7M, mas os pesos de embedding treinados junto passam de 100 milhões, o que o coloca numa faixa parecida com a do mdlARC.
Na ponta oposta estão os LLMs de fronteira. O Gemini 3.1 Pro, em fevereiro de 2026, atingiu 77,1% no ARC-AGI-2 com custo de 0,962 dólar por tarefa no modo de maior computação. E o vencedor do ARC Prize 2025, a equipe NVARC, da NVIDIA, chegou a 24,03% no conjunto privado do ARC-AGI-2 gastando cerca de 0,20 dólar por tarefa, com um Qwen de 4 bilhões de parâmetros e muitos dados sintéticos.
Um script rápido deixa a comparação de custo honesta, porque a unidade que importa não é o custo total, e sim quanto custa cada tarefa resolvida:
# Custo por acerto = custo por tarefa / taxa de acerto.
# Os custos por tarefa de o3, NVARC e Gemini 3.1 Pro são os publicados pela ARC Prize;
# o do mdlARC é o custo total dividido pelas 400 tarefas do conjunto público.
abordagens = {
# nome: (benchmark, acerto em %, custo por tarefa em US$)
"mdlARC (Vakde, RTX 5090)": ("ARC-AGI-1 público", 44.0, 0.67 / 400),
"o3 modo eficiente (dez/2024)": ("ARC-AGI-1 semi-privado", 75.7, 20.0),
"NVARC (ARC Prize 2025)": ("ARC-AGI-2 privado", 24.03, 0.20),
"Gemini 3.1 Pro high (fev/2026)": ("ARC-AGI-2 semi-privado", 77.1, 0.962),
}
for nome, (bench, acerto, custo_tarefa) in abordagens.items():
custo_por_acerto = custo_tarefa / (acerto / 100)
print(f"{nome:32} {bench:24} {acerto:5.1f}% "
f"US$ {custo_tarefa:.5f}/tarefa US$ {custo_por_acerto:.4f}/acerto")O que a conta mostra é que existem dois jogos diferentes. Os LLMs jogam o jogo do acerto absoluto, e o ARC-AGI-1 está resolvido para eles. O mdlARC, o TRM e o HRM jogam o jogo da eficiência amostral: quanto de raciocínio abstrato dá para extrair de um modelo pequeno, do zero, sem pré-treino em internet nenhuma. No ARC-AGI-2, esses modelos pequenos ainda estão na casa de um dígito, e o próprio Vakde reconhece que o ARC-AGI-3, com ambientes interativos, exigiria modelos bem maiores.
O Que a Thread do Hacker News Discutiu
Além do debate sobre trapaça, três pontos valem registro.
O primeiro é sobre o custo. Um comentarista alertou que o "0,67 dólar" é enganoso se alguém extrapolar linearmente e imaginar que 100 dólares dariam 65%. O autor concordou que o número ilustra eficiência, não escala linear.
O segundo é sobre o que os LLMs realmente aprendem. Para Vakde, os modelos de fronteira chegam ao ARC por pós-treino sintético: eles aprendem a resolver tarefas de ARC, não a raciocinar de forma abstrata em geral. É uma crítica antiga ao benchmark, e é um dos motivos de a ARC Prize ter lançado o ARC-AGI-3 em 25 de março de 2026, com ambientes interativos em que o agente precisa descobrir o objetivo sozinho.
O terceiro é sobre o mundo real. Um comentário levantou o problema do enquadramento: o método pode estar explorando o tamanho limitado do ARC e falhar em distribuições reais. O autor reconheceu em parte e deixou a resposta para trabalhos futuros. É uma limitação honesta, e ela precisa entrar em qualquer leitura empolgada do resultado.
Como Reproduzir por 67 Centavos
O repositório é MIT e o passo a passo cabe num terminal. Na vast.ai, uma RTX 5090 sob demanda sai por volta de 0,33 dólar a hora em setembro de 2026, o que fecha a conta das 2 horas. A placa tem 32 GB de GDDR7, e o autor pede CUDA acima de 12.8, de preferência 13.
# Clona o repositório (licença MIT); antes, crie um venv e instale
# torch, numpy, numba, matplotlib e flash-attn
git clone https://github.com/mvakde/mdlARC.git
# Baixa e monta os datasets: ARC-AGI-1 + ConceptARC + tarefas filtradas do ARC-AGI-2
cd mdlARC/dataset_building_scripts
python download_and_group.py
python build_datasets.py arc1 --add-conceptarc --with-filtered
cd ..
# Opcional: apaga dados brutos e o arquivo de soluções para provar que não há vazamento
# rm -r assets_tmp
# rm assets/solutions.json
# rm -r dataset_building_scripts
# Treino + inferência. Modos: low, medium ou high
python run_script.py highO passo opcional de apagar os dados brutos e o arquivo de soluções antes do treino existe para provar que não há vazamento, e vale rodar se você pretende publicar o seu número. O script de treino tem três modos, low, medium e high, e o autor desligou o log da função de perda para ganhar velocidade.
Se você não quer gastar nem os 67 centavos, os modos low e medium reduzem o orçamento de computação e o código roda numa GPU local, mais devagar. O que não dá é rodar em CPU num tempo razoável: flash attention é requisito.
Eficiência Contra Escala: O Que Isso Muda Para Quem Desenvolve
O ARC Prize 2026 está em andamento com mais de 2 milhões de dólares em prêmios. A trilha do ARC-AGI-2 paga 700 mil dólares, e a regra do Kaggle é dura: 240 tarefas em 12 horas com quatro GPUs L4, algo como 0,42 dólar por tarefa, sem internet e com código aberto obrigatório. O grande prêmio exige 85% no conjunto privado. Nesse regime, um Gemini 3.1 Pro a 0,962 dólar por tarefa nem entra na sala. É exatamente o regime em que um transformer de 75 milhões de parâmetros treinado em 2 horas faz sentido.
Três leituras práticas para você que desenvolve.
A primeira é que a fronteira de pesquisa acessível continua aberta. Uma pessoa, uma placa alugada e um repositório MIT empataram com o laboratório da Samsung e com o estado da arte não-LLM de 2025. Se você quer entrar em pesquisa de IA, o ARC é um campo onde 67 centavos de experimento cabem no orçamento de qualquer um.
A segunda é sobre a receita. SwiGLU, RMSNorm, RoPE, flash attention e otimizadores da família Muon não são exclusividade de modelo gigante; eles rendem em 75 milhões de parâmetros tanto quanto em 75 bilhões. Se você mantém um modelo pequeno em produção, um classificador, um gerador de embeddings, um transformer de séries temporais, vale revisar a arquitetura com essa lista na mão. Eu falei sobre esse movimento no post sobre small language models e a IA acessível, e o mdlARC é o exemplo mais extremo dele até agora.
A terceira é sobre o que vem depois. Vakde afirma estar seguro de que 65% é alcançável dentro do framework do transformer e convida quem quiser a tentar. O ARC-AGI-2 continua com um dígito para essa família de modelos, e o ARC-AGI-3 é outro jogo. A pergunta que o post deixa no ar é a mesma da thread: o caminho para o raciocínio geral passa por escalar o que já temos, ou por descobrir o que faz um modelo pequeno aprender com dois exemplos? Em 2026, pela primeira vez, dá para testar as duas hipóteses com o dinheiro de um café.
Bora pra cima! 🦅
📚 Quer Acompanhar o Que Vem Por Aí?
Este artigo cobriu o transformer de 67 centavos que marcou 44% no ARC-AGI-1, mas o ecossistema muda toda semana e nem tudo vira artigo aqui.
No X eu compartilho o que estou testando, os bastidores dos projetos e as novidades que aparecem antes de virarem post.
Me Segue Lá
💡 Conteúdo diário sobre desenvolvimento, carreira e as ferramentas que eu realmente uso