Thinking Machines lança Inkling 2 Mini, modelo de IA multimodal para rodar fora da nuvem
A Thinking Machines Lab publicou em 20 de novembro de 2026 o Inkling 2 Mini, um modelo multimodal de 26 bilhões de parâmetros que usa só 3 bilhões por token e já roda em notebook, Mac ou GPU única via llama.cpp, MLX e SGLang.
· 8 min de leitura
Este artigo foi escrito por Lucas Ferraz. Conteúdo produzido por agente de IA da redação AI Brasil, sob revisão editorial humana. Saiba como produzimos no expediente.
A Thinking Machines Lab publicou em 20 de novembro de 2026 o Inkling 2 Mini, um modelo multimodal de 26 bilhões de parâmetros que usa só 3 bilhões por token e já roda em notebook, Mac ou GPU única via llama.cpp, MLX e SGLang.
A Thinking Machines Lab, em parceria com a equipe da Hugging Face, publicou em 20 de novembro de 2026 o Inkling 2 Mini: um modelo de IA multimodal (texto e imagem) pensado para rodar na própria máquina do desenvolvedor, sem passar por API de terceiros. É a versão enxuta de um modelo maior, o Inkling 2 Small, e o anúncio saiu no blog oficial da Hugging Face, assinado por membros da equipe de modelos abertos (merve, Pedro Cuenca, Aritra Roy Gosthipaty e Guarin Flück).
O ângulo que interessa a quem constrói agente ou integra IA num sistema interno é direto: menos dependência de latência de rede, nenhum custo por token cobrado por fornecedor externo e controle total sobre o que acontece com os dados, já que tudo roda local. Mas isso não significa hardware leve. A seguir, o que o modelo faz por baixo do capô, como rodar e onde ele ainda não foi validado o suficiente para produção.
Poucos parâmetros ativos não é sinônimo de pouca memória
Inkling 2 Mini é um modelo de mistura de especialistas (MoE, na sigla em inglês): ele tem cerca de 26 bilhões de parâmetros no total, mas ativa só 3 bilhões a cada token processado. Isso reduz o custo de computação por requisição, mas não reduz o espaço que o modelo ocupa na memória, porque todos os especialistas (os blocos de parâmetros entre os quais o roteador escolhe) precisam estar carregados, mesmo os que não são usados naquele token específico.
Na prática, isso é o detalhe que mais separa teoria de operação real: um MoE de 26B pode responder tão rápido quanto um modelo denso de 3B, mas para carregá-lo é preciso memória equivalente a um modelo bem maior. É esse equilíbrio entre velocidade de resposta e tamanho em disco que o leitor precisa calcular antes de escolher a máquina.
O truque do loop: 24 camadas físicas viram 48 passagens por token
O modelo tem 24 camadas de decodificador fisicamente armazenadas, mas as 12 camadas do meio são executadas em loop, repetidas três vezes. Isso dá ao modelo o comportamento de 48 passagens lógicas (6 camadas iniciais + 3×12 do núcleo repetido + 6 camadas finais) usando o peso de apenas 24 camadas reais. É uma forma de ganhar capacidade sem multiplicar o tamanho do arquivo de pesos.
Cada passagem pelo núcleo repetido não começa do zero: ela lê uma "mensagem" da passagem anterior, calculada com uma consulta aprendida própria para as entradas de atenção e da camada MoE. Um controlador de gating decide quanto do dado atual descartar e quanto da mensagem anterior incorporar, refinando o resultado a cada volta. Arquiteturas como a Nanbeige já tinham explorado loop antes, mas esse mecanismo de troca de mensagens entre passagens é a parte nova do Inkling 2 Mini.
O roteador de cada camada escolhe 8 de 128 especialistas SwiGLU disponíveis por camada (no Inkling 2 Small são 384 especialistas por camada, com largura de estado oculto de 4.608 contra 2.304 no Mini). A atenção usa 24 cabeças de consulta e 8 de chave/valor, com janela local de até 1.024 tokens em cinco das seis camadas de cada bloco; a sexta camada do bloco faz atenção completa.
| Característica | Inkling 2 Mini | Inkling 2 Small |
|---|---|---|
| Largura do decodificador | 2.304 | 4.608 |
| Especialistas por camada | 128 | 384 |
| Experts ativados por token | 8 | 8 |
| Passagens lógicas por token | 48 | 48 |
Como rodar localmente, com código
A Hugging Face publicou suporte dia zero em quatro caminhos: transformers, Llama App (interface sobre o llama.cpp), MLX (para Apple Silicon) e SGLang (para servidor de produção). Para uso em transformers, o modelo usa a classe AutoModelForMultimodalLM:
import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "thinkingmachines/Inkling-2-Mini"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id)
messages = [{"role": "user", "content": [{"type": "text", "text": "Why is the sky blue?"}]}]
inputs = processor.apply_chat_template(
messages, tokenize=True, add_generation_prompt=True,
return_dict=True, return_tensors="pt",
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024)Para rodar localmente sem GPU dedicada, o caminho mais acessível é o llama.cpp, com pesos convertidos para GGUF em dois formatos: IQ4_NL (4 bits) e Q8_0 (8 bits). O comando de servidor é simples:
llama serve -hf ggml-org/Inkling-2-Mini-GGUF:IQ4_NLA Hugging Face não publicou o tamanho exato dos arquivos GGUF, mas uma conta aproximada ajuda a dimensionar a máquina: 26 bilhões de parâmetros em IQ4_NL (perto de 4,5 bits por peso, com overhead) ficam em torno de 14 a 15 GB; no formato Q8_0 (cerca de 8,5 bits por peso) o arquivo passa dos 26 GB. É estimativa própria baseada na matemática padrão de quantização, não um número divulgado pela fonte, mas dá a régua: o quantizado de 4 bits cabe numa GPU de consumo de 16 GB ou num Mac com memória unificada equivalente; o de 8 bits já pede hardware mais robusto.
No MLX, o modelo roda com o esquema nativo de precisão mista NVFP4 (pesos regulares) e MXFP8 (pesos dos especialistas) sem reconversão, preservando a qualidade original do checkpoint:
mlx_lm generate --model thinkingmachines/Inkling-2-Mini --image image.jpg \
--prompt "Describe this image." -m 1000Para servir em produção em GPU de datacenter, o SGLang exige hardware da classe SM103 (Blackwell, como a B300 usada nos benchmarks da própria equipe), com aceleração extra via o drafter DSpark para decodificação especulativa:
python -m sglang.launch_server --model-path thinkingmachines/Inkling-2-Mini \
--served-model-name inkling --attention-backend fa4 \
--tp 1 --page-size 128 --speculative-algorithm DSPARK --context-length 131072Nos benchmarks de terceiros, ele vence na maioria dos testes, mas perde em automação
O índice Artificial Analysis Intelligence Index v5 (AAv5), medido por avaliador independente, coloca o Inkling 2 Mini à frente de concorrentes da mesma faixa de porte, como Gemma 4 31B, Muse Glimmer, Qwen3.8-27B e Nemotron 3.5 Super VL, em 32 de 48 benchmarks cobrindo código, pesquisa autônoma, uso de ferramentas, interpretação de imagem e segurança. Em código especificamente, o Inkling lidera no FrontierCode v2.0, empata com Qwen3.8-27B no Terminal-Bench 4.0 e fica atrás do mesmo concorrente no AutomationBench-AA v1.0.6, o benchmark de automação de tarefas.
Separado disso está o teste informal que a própria Hugging Face chama de "vibe test", sem metodologia de benchmark formal:
Em nossos testes informais, ele é ao menos comparável ao Qwen 3.8 27B. Mais validação é necessária, mas estamos muito empolgados com este lançamento.
In our vibe tests, it's at least comparable with Qwen 3.8 27B. More validation is needed, but we are super excited about this release!Equipe de modelos abertos da Hugging Face, blog post sobre Inkling 2 Mini
Vale separar os dois: o AAv5 é medição de terceiro, com benchmark público e comparável; o "vibe test" é opinião informal do próprio time que publicou o modelo, útil como indício, não como prova.
Chamada de ferramentas funciona pronta para uso em agente
Para quem monta agente, o suporte a tool calling já vem embutido no processador. O exemplo abaixo (do próprio material oficial) mostra o modelo decidindo sozinho chamar uma função e preencher os argumentos:
def get_current_temperature(location: str, unit: str):
return 22.0 # chamaria uma API de clima real aqui
messages = [{"role": "user", "content": "Hey, what's the temperature in Paris right now?"}]
reply = ask(messages)
call = reply["tool_calls"][0]["function"]
# Model calls: get_current_temperature {'location': 'Paris, France', 'unit': 'celsius'}O modelo também aceita um parâmetro reasoning_effort para controlar quanto raciocínio gastar por resposta: none (0.0), minimal (0.1), low (0.2), medium (0.7), high (0.9, padrão), xhigh (0.99) e max (0.99), ou qualquer valor numérico entre 0.0 e 0.99 passado diretamente. É um controle direto de custo de inferência: menos raciocínio, resposta mais rápida e mais barata em computação, ao custo de qualidade.
O que ainda não foi validado o suficiente para produção
Além do modelo principal, a Thinking Machines liberou uma variante de pesquisa, chamada TML-d24-varloop-research, com a mesma arquitetura mas treinada para aceitar um número variável de passagens pelo loop (1, 2 ou 3) em vez de sempre 3. Rodar com menos passagens acelera a inferência, mas a própria equipe admite que "funciona, mas não avaliamos em profundidade". Para quem decide usar em produção, essa é a variante a tratar como experimental, reservada para prototipagem.
Os demos de código mostrados no anúncio foram feitos com um harness de codificação interno chamado Pi, mas cada um passou por um processo de verificação diferente. O shader WebGL recriando a pintura Noite Estrelada, de Van Gogh, passou por até 24 rodadas de checagem por captura de tela antes do resultado final.
Já o app de divisão de despesas de viagem, gerado a partir de um esboço em papel, foi produzido em três tentativas independentes verificadas via Playwright, com a primeira tentativa passando em todas as 13 checagens. São demonstrações de capacidade, não benchmark reprodutível, e servem mais como indício de que o modelo sustenta tarefas de geração de código mais longas do que como medida formal de qualidade.
Fonte: Hugging Face Blog

Cobre a parte técnica da inteligência artificial para quem constrói e opera sistemas: desenvolvedores, analistas e times de TI. Compara modelos, mostra o código e o prompt, mede o resultado e diz quanto custa, para o leitor conseguir repetir na própria empresa.