Claude Mythos: O Modelo que Pensa em Ciclos

O Claude Mythos não pensa uma vez e responde. Pensa de novo. E de novo. Até decidir que acabou.

Todos os modelos de IA que usaste até agora funcionam da mesma forma: fazes uma pergunta, o modelo lê-a uma vez, prevê palavra a palavra, dá uma resposta. Uma passagem. Acabou. O Claude Mythos suspeita-se que funcione de forma completamente diferente: os mesmos pesos, correndo em loop, com cada passagem a refinar o que a anterior errou. Como dormir sobre um problema difícil, só que faz 16 sonecas num único segundo, todas invisíveis, antes de escrever uma primeira palavra.

Essa é a hipótese. Em abril de 2026, um developer chamado Kye Gomez fez engenharia reversa do design suspeito a partir de documentos Anthropic vazados e publicou-o no GitHub antes de a Anthropic dizer uma palavra publicamente. Este post explica como funciona e como podes correr tu mesmo hoje.

O que os modelos de IA normais fazem realmente

Pensa em cada IA que usaste como uma linha reta.

Escreves uma pergunta. O modelo passa-a pela camada 1, depois pela camada 2, depois pela camada 3. Cada camada é um conjunto separado de pesos treinados, usado exatamente uma vez, em sequência. O GPT-4 tem cerca de 120 destas camadas. Cada camada adiciona ao tamanho do ficheiro do modelo, à pegada de memória e ao custo de computação. Para tornar um modelo mais inteligente, adiciona-se mais camadas. Mais camadas significam mais parâmetros. Mais parâmetros significam mais GPUs para o correr.

Este é o muro com que todos os modelos de fronteira se estão a deparar. Não "como pensamos melhor?" mas "como encaixamos mais camadas?" O Claude Mythos parece ter sido desenhado em torno de uma pergunta completamente diferente: e se uma camada pudesse fazer o trabalho de muitas?

A ideia central: uma camada, corrida várias vezes

A hipótese Mythos resume-se a uma mudança arquitetural.

Em vez de 6 camadas únicas com 6 conjuntos de pesos, o modelo tem 1 camada com 1 conjunto de pesos. Essa camada corre 5 vezes (ou quantas vezes o input exigir). Os mesmos pesos em cada passagem. O output de cada passagem torna-se o input para a seguinte.

O modelo é menor para armazenar. Mas igualmente profundo em termos de quantos passos de processamento o input atravessa.

Esta classe de arquitetura chama-se recurrent-depth. A palavra "recurrent" significa o mesmo que nas RNNs: um processo que alimenta o seu output de volta como próprio input. A diferença é que o Mythos aplica esta ideia à camada transformer completa, não apenas ao estado oculto.

A estabilidade LTI é o que impede essas passagens repetidas de explodir. LTI significa Linear Time-Invariant. É um conceito da teoria de controlo que descreve sistemas onde o mesmo input produz sempre o mesmo output, independentemente de quando o aplicas. Num modelo em loop, sem restrições de estabilidade, os erros acumulam-se entre passagens e as ativações explodem. A estabilidade LTI previne isso. A camada é desenhada para que corrê-la repetidamente mantenha os valores num intervalo limitado em vez de derivar para o infinito.

Cada passagem refina a resposta

Pensa nas passagens como rascunhos.

A passagem 1 é o primeiro pensamento aproximado. O modelo lê o input e gera uma representação inicial. Não está errada exatamente, é apenas superficial.

A passagem 2 pega nessa representação e processa-a novamente. Pode apanhar coisas que a primeira passagem falhou. As contradições são sinalizadas. A resposta começa a afinar-se.

Cada passagem subsequente corre os mesmos pesos numa representação cada vez mais refinada do problema. Na passagem N, o modelo teve N oportunidades de trabalhar a questão. O output é o resultado da passagem final.

É isto que o carrossel descreve como "Mesmo cérebro. Corrido de novo." Os pesos não mudam entre passagens. O que muda é a qualidade da representação sobre a qual esses pesos trabalham. Cada loop acrescenta profundidade.

O LoRA por profundidade encaixa aqui. LoRA (Low-Rank Adaptation) é uma técnica para tornar modelos treináveis com menos parâmetros, aproximando as atualizações de pesos como produto de duas matrizes menores. Num modelo de profundidade recorrente, o LoRA por profundidade adiciona pequenos ajustes em cada passagem para que a mesma camada base se possa comportar ligeiramente diferente na passagem 2 do que na passagem 1, mesmo que os pesos centrais sejam partilhados. É assim que o modelo evita fazer exatamente o mesmo em cada loop.

A atenção MLA (Multi-head Latent Attention) é o mecanismo de atenção suspeito de correr dentro de cada passagem. A atenção multi-cabeça padrão é cara: as matrizes de chave e valor crescem com a janela de contexto, e tens de as cachear para cada camada. O MLA comprime a cache chave-valor projetando-a num espaço latente menor. Num modelo que corre a mesma camada repetidamente, isto importa muito. Sem compressão, os custos de memória multiplicam-se com cada loop. O MLA mantém-nos geríveis.

O MoE FFN (Mixture of Experts Feed-Forward Network) trata da parte feed-forward de cada passagem. Num transformer padrão, cada token ativa todos os parâmetros no bloco feed-forward. O MoE usa um router para ativar apenas um subconjunto de sub-redes "especialistas" para cada token. Isto significa que o modelo pode ter uma contagem total de parâmetros elevada no bloco FFN enquanto usa apenas uma fração desses parâmetros por passagem forward. No contexto Mythos, o MoE acrescenta capacidade a cada passagem de loop sem aumentar proporcionalmente o custo de computação de a correr.

Perguntas difíceis recebem mais loops

Esta é a parte que torna a profundidade recorrente genuinamente diferente de simplesmente tornar um modelo maior.

Um modelo padrão corre todos os inputs por todas as camadas, sempre. Quer escrevas "Olá" quer escrevas "Explica a base termodinâmica para a flecha do tempo," o custo de computação é o mesmo. O número de camadas é fixo.

Num modelo de profundidade recorrente com halting ACT, isso deixa de ser verdade.

ACT significa Adaptive Computation Time. É um mecanismo que permite ao modelo decidir quantas passagens correr antes de produzir o seu output. Em cada passagem, o modelo produz uma "probabilidade de halting" a par da sua representação. Quando a probabilidade de halting acumulada cruza um limiar, o loop para e a representação atual torna-se o output.

O resultado é um modelo que aloca computação conforme a dificuldade da pergunta:

Tokens fáceis recebem 2 loops. Tokens difíceis recebem 10. Nada é desperdiçado. O modelo não gasta 10 loops em "Olá" só porque a arquitetura o permite.

Esta é também parte da razão pela qual, dentro de 24 horas do anúncio público da Anthropic, o Secretário do Tesouro dos EUA e o Presidente da Reserva Federal convocaram uma reunião fechada de emergência com os CEOs dos principais bancos sobre as implicações de cibersegurança deste modelo. Um modelo que gere o seu próprio cálculo e decide com que profundidade pensar sobre algo é uma classe de sistema diferente de um que corre sempre o mesmo número fixo de passagens. A superfície de controlo para alinhamento e previsões de capacidade muda.

Alguém reconstruiu-o em open source

A Anthropic nunca confirmou a arquitetura publicamente. Mas Kye Gomez fez a próxima melhor coisa: leu as evidências disponíveis, inferiu o design e fez engenharia reversa de uma implementação funcional.

O projeto é kyegomez/OpenMythos no GitHub, publicado em 2026.

A arquitetura corresponde a todas as pistas que vazaram da investigação da Anthropic. O vazamento da especificação do modelo no início de 2026 expôs rascunhos de posts de blog e documentos internos que referenciavam designs de pesos em loop. O vazamento do source map do @anthropic-ai/claude-code versão 2.1.88 expôs feature flags internas e notas de arquitetura consistentes com raciocínio de profundidade recorrente. Nada disso foi um blueprint direto. Kye Gomez preencheu os espaços em branco.

A comunidade lançou-o antes de a Anthropic dizer uma palavra publicamente.

Como correr a tua própria versão

O OpenMythos é o caminho mais rápido para correr um modelo de profundidade recorrente localmente. Aqui está o mínimo necessário.

O que vais precisar:

• Python 3.10+
• PyTorch 2.1+
• 8GB+ de VRAM para configs pequenas, 24GB+ para escala significativa
• Git

Clonar e instalar:

git clone https://github.com/kyegomez/OpenMythos
cd OpenMythos
pip install -r requirements.txt

O loop central em termos simples. O OpenMythos define um único bloco transformer, depois envolve-o num loop com uma cabeça de halting ACT. A cabeça de halting é uma pequena camada linear que lê o estado oculto atual e produz um escalar entre 0 e 1. Quando a pontuação de halting acumulada passa um limiar (tipicamente 0.99), o loop sai. Aqui está a forma conceptual:

# Simplified recurrent-depth forward pass
hidden = embed(input_tokens)

halt_acc = 0.0
n_steps = 0

while halt_acc < 0.99 and n_steps < max_loops:
    hidden = transformer_block(hidden)          # same weights every pass
    halt_prob = halt_head(hidden).sigmoid()     # how confident to stop?
    halt_acc += halt_prob * (1 - halt_acc)
    n_steps += 1

output = lm_head(hidden)

O transformer_block corre os mesmos pesos em cada passagem. O halt_head decide quando parar. O modelo nunca toma mais passagens do que max_loops, por isso podes limitar a computação.

LoRA por profundidade na prática. Para permitir que o modelo se comporte diferentemente em cada passagem sem pesos separados, o OpenMythos injeta embeddings de índice de passagem antes do bloco transformer. Cada passagem recebe um pequeno offset aprendido que desloca ligeiramente a representação. Os pesos base ficam partilhados; os offsets dão a cada passagem o seu próprio caráter:

# Pass index conditioning
pass_embed = self.pass_embeddings(torch.tensor(n_steps))
hidden = hidden + pass_embed
hidden = self.transformer_block(hidden)

Esta é uma versão lightweight do LoRA por profundidade. Uma implementação completa usaria adaptadores low-rank por passagem em vez de offsets aprendidos, mas o princípio é o mesmo.

Treino com ACT. A loss de treino adiciona um termo de regularização que penaliza passagens desnecessárias. Sem ele, o modelo aprenderia sempre a correr o número máximo de loops independentemente da dificuldade do input. O custo de ponderação empurra-o a parar cedo quando a representação já é suficientemente boa:

loss = cross_entropy_loss + lambda_ponder * n_steps.float().mean()

O coeficiente lambda_ponder controla o tradeoff entre qualidade da resposta e eficiência de computação. Valores mais altos produzem modelos mais rápidos e superficiais. Valores mais baixos produzem pensadores mais profundos que usam mais passagens.

Porque é que esta arquitetura importa

Três coisas mudam se a profundidade recorrente se tornar a abordagem padrão para modelos de fronteira.

Profundidade sem o volume. Um modelo pode raciocinar tão profundamente quanto um com 6x as camadas enquanto armazena apenas os pesos de 1 camada. Ficheiros de modelo menores, requisitos de memória mais baixos, mais barato de servir. Obténs a qualidade de output de um modelo grande ao custo de armazenamento de um pequeno.

Computação variável por token. O modelo gasta computação onde o problema é realmente difícil. Um prompt que é 90% contexto fácil e 10% raciocínio difícil não paga o mesmo custo por token que um prompt uniformemente difícil. Isto muda o que "inferência eficiente" significa.

Um novo eixo de design para capacidade. A abordagem padrão para tornar modelos mais inteligentes é treinar modelos maiores em mais dados. A profundidade recorrente acrescenta um eixo diferente: profundidade de raciocínio por passagem forward. Um modelo pode ser tornado "mais inteligente" ao permitir mais loops, não apenas adicionando parâmetros. Loops, não camadas.

Se a Anthropic acertou nisto, o manual para escalar inteligência acabou de mudar. Não mais pesos. Mais passagens.

O que não sabemos

Vale a pena ser claro sobre o que isto é e o que não é.

A Anthropic não confirmou publicamente que o Claude Mythos usa arquitetura de profundidade recorrente. A evidência é indireta: documentos de especificação de modelo vazados, conteúdo de source maps, comportamento de benchmarks consistente com computação adaptativa, e o trabalho de engenharia reversa de Kye Gomez. A arquitetura encaixa. Não foi verificada.

O OpenMythos é uma implementação comunitária de um design suspeito. Não é um produto Anthropic e não reproduz nenhum código de treino ou pesos reais da Anthropic.

O modelo Mythos prático, se existir como descrito, é o lançamento mais restrito da Anthropic. Não está disponível para o público. O que podes correr hoje é o OpenMythos: a hipótese arquitetural tornada executável.

Esta distinção importa. Correr o OpenMythos ensina-te como a profundidade recorrente funciona. Não te dá o Claude Mythos.

Onde o padrão se aplica

A ideia de profundidade recorrente não é única à especulação sobre o Mythos. A mesma abordagem apareceu em investigação académica com nomes diferentes: Universal Transformers (Dehghani et al., 2018), Pondering (Banino et al., 2021), e mais recentemente em trabalho focado em eficiência sobre inferência adaptativa em profundidade.

O que o Mythos representa, se a hipótese estiver certa, é a Anthropic a aplicar esta direção de investigação à escala de fronteira com engenharia de nível de produção. Isso importa porque o trabalho anterior de profundidade recorrente ficou maioritariamente no laboratório de investigação. Escalá-lo para um modelo suficientemente capaz ao ponto de a Anthropic restringir o seu acesso é um resultado de classe diferente.

O caminho open-source existe. Kye Gomez construiu-o. A arquitetura é compreensível. As peças (halting ACT, MoE FFN, LoRA por profundidade, atenção MLA) estão cada uma documentada independentemente na literatura de investigação.

Um loop de cada vez, a representação fica melhor. É essa a ideia toda.

Publicado por @speedy_devv