Flint 40B: o melhor LLM de médio porte

Autoria: Data Science in your pocket · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Flint 40B : Best Mid Sized LLM · Canal: Data Science in your pocket · 09:17 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Inferência e otimização de modelos, Modelos de IA, Modelos locais e open source

Resumo

Flint é um modelo de programação com 40 bilhões de parâmetros, desenvolvido pela startup Recursive para rodar localmente, com pesos abertos sob Apache 2.0. Por ser um modelo mixture of experts, ativa cerca de 2,5 bilhões de parâmetros por token e alcança mais de 125 tokens por segundo em determinados hardwares. A Eureka machine automatizou decisões de arquitetura, quantização e criação de kernels especializados. O vídeo ressalta que os resultados foram medidos pelos desenvolvedores e que Flint não supera os maiores modelos fechados em qualidade absoluta.

Pontos-chave

Flint é um modelo de programação local com 40 bilhões de parâmetros e pesos licenciados sob Apache 2.0.
O modelo ativa cerca de 2,5 bilhões de parâmetros por token, usando uma arquitetura mixture of experts.
Os desenvolvedores relatam resultados competitivos em SWE-bench Pro, SWE-bench Verified e Terminal Bench.
Com o mecanismo de inference da Recursive, Flint supera 125 tokens por segundo em um MacBook com M4.
A Eureka machine explorou configurações de arquitetura e selecionou uma combinação de throughput e capacidade.
A camada de saída foi quantizada para quatro bits, com uma etapa de distillation para recuperar qualidade.
Kernels especializados, incluindo um mega kernel para chips M4 e M5, ajudam a reduzir a sobrecarga de execução.
A versão de precisão total requer cerca de 48 GB de memória; versões quantizadas são mais adequadas para máquinas pessoais.
O vídeo observa que os benchmarks são resultados dos próprios desenvolvedores e recomenda compará-los com cautela.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação de Flint e suas promessas	O vídeo apresenta Flint, seu uso local, a licença aberta e as alegações de desempenho e eficiência.
02:35	Arquitetura e funcionamento	A transcrição descreve a arquitetura mixture of experts, a atenção e o contexto de Flint.
04:07	A Eureka machine e as decisões de projeto	O vídeo explica como o sistema automatizado pesquisou a arquitetura e conduziu a quantização da camada de saída.
06:11	Kernels e execução local	São apresentados os kernels especializados, as opções de distribuição e os requisitos práticos para rodar Flint.
08:17	Limitações e avaliação final	O vídeo contextualiza os benchmarks, aponta limitações de qualidade e memória e resume a proposta de eficiência de Flint.

Citações

Seu código nunca sai da máquina. Sem taxas de API, sem limites de uso, funciona offline. — 00:30

Mesma qualidade, uma fração do custo computacional. — 02:03

A versão final de quatro bits fica a até 0,7 ponto do modelo de precisão total no conjunto completo de benchmarks. — 06:11

A alegação é a melhor capacidade por unidade de computação na sua classe, não a melhor no geral. — 08:17

Um modelo construído pelo assistente de pesquisa do seu próprio sucessor. — 09:17

Conceitos e entidades

Flint (modelo): Modelo de programação de 40 bilhões de parâmetros desenvolvido pela Recursive para execução local.
Recursive (empresa): Startup que desenvolveu Flint e a Eureka machine.
Eureka Machine (ferramenta): Sistema automatizado de pesquisa em IA que propõe, implementa e avalia experimentos.
Mixture of Experts (conceito): Arquitetura que ativa apenas um subconjunto de especialistas para processar cada token.
quantization (conceito): Técnica de redução da precisão numérica dos parâmetros para diminuir o custo computacional e o uso de memória.
distillation (conceito): Etapa de treinamento em que um modelo aprende com respostas produzidas por um modelo professor.
RecEngine (ferramenta): Mecanismo leve da Recursive que inclui os kernels usados para executar Flint.
Hugging Face (empresa): Plataforma onde, segundo o vídeo, os pesos de Flint estão disponíveis.
llama.cpp (ferramenta): Projeto de software citado como uma das opções para executar Flint.
SWE-bench Pro (benchmark): Benchmark de programação citado para avaliar o desempenho agentic de Flint.

Tradução completa (pt-BR)

00:00 Aqui vai uma pergunta que costumava ter uma resposta óbvia. Quem desenvolve modelos de IA de ponta? Pessoas. O assunto de hoje muda essa resposta. Este é o Flint, um modelo de programação com 40 bilhões de parâmetros de uma startup chamada Recursive. Ele roda no seu laptop. Seus pesos são abertos sob a licença Apache 2.0, e quase todas as decisões de design internas foram tomadas por um sistema automatizado de pesquisa chamado Eureka machine. Uma pequena equipe de pessoas e agents o montou do zero em menos de 4 meses.

00:30 Vamos abri-lo peça por peça e ver como é um modelo construído por uma máquina. A proposta: um agent de programação para o dia a dia que roda inteiramente no seu próprio hardware. Seu código nunca sai da máquina. Sem taxas de API, sem limites de requisições, funciona offline. O porém: laptops têm recursos limitados, então o modelo precisa ser extremamente eficiente. Flint pertence à classe dos modelos de mixture of experts com menos de 50 bilhões de parâmetros no total. Três afirmações o definem.

01:00 Uma: os melhores resultados de programação agentic nessa classe. Duas: até duas vezes mais velocidade que modelos comparáveis. Três: mais de cinco vezes mais rápido que modelos densos com pontuações semelhantes. Velocidade vezes qualidade: vamos conferir os dados. Três benchmarks agentic dão o tom. SWE-bench Pro versão 2: 89,7%. SWE-bench verified: 74,2%. Terminal bench 2.1: 54,9,

01:32 e esse benchmark é avaliado com rigor. Qualquer solução obtida na web conta como falha. Esses números vêm de testes feitos pelos próprios desenvolvedores com o checkpoint de precisão total, temperatura 1, e cada pontuação agentic é a média de pelo menos cinco tentativas, com um tempo limite de até cinco horas por tarefa. Para contextualizar, Flint supera todos os modelos de mixture of experts com menos de 50 bilhões de parâmetros e compete de igual para igual com modelos densos de tamanho total semelhante. Agora, a outra metade da equação: velocidade. Com o próprio mecanismo de inference da Recursive,

02:03 Flint gera mais de 125 tokens por segundo em um MacBook M4 e mais de 150 em um RTX Spark de 64 GB. Em comparação com outros modelos de mixture of experts da mesma classe, isso representa até duas vezes mais velocidade. E, em comparação com modelos densos de 25 a 40 bilhões de parâmetros que alcançam pontuações semelhantes em programação, ele é mais de cinco vezes mais rápido. A mesma qualidade, com uma fração do poder computacional. Essa é a promessa de ativar apenas uma pequena parte da rede. Então, como funciona esse truque?

02:35 Flint é um transformer mixture of experts somente decoder com 39,8 bilhões de parâmetros — arredondando, 40 bilhões. Mas cada token ativa apenas cerca de 2,5 bilhões deles. A arquitetura tem 49 camadas: duas densas, seguidas por 47 camadas mixture of experts. Em cada uma delas há 256 experts roteados, e um pequeno roteador seleciona seis deles por token, além de um expert compartilhado que está sempre ativo. A atenção usa 32 cabeças de query, mas apenas

03:05 quatro cabeças de key-value, com grouped query attention; cada cabeça tem 128 dimensões. A configuração de atenção é híbrida. 35 das 47 camadas mixture usam sliding window attention com uma janela de 513 tokens: o token atual mais os 512 vizinhos mais próximos. As 14 camadas restantes veem todo o contexto. Repare na combinação: codificação posicional rope nas camadas de janela deslizante e nenhuma codificação posicional nas camadas de atenção completa.

03:36 Q e K recebem RMS norm por cabeça, além de attention sinks aprendidos para dar estabilidade. O contexto chega a meio milhão de tokens, embora o ponto ideal para precisão seja 256.000. Há uma peculiaridade que será importante mais adiante. O vocabulário do Flint contém cerca de 150.000 tokens, então a camada de saída — a matriz que mapeia os estados ocultos de volta para palavras — é enorme, com cerca de 300 milhões de parâmetros. E, como apenas 2,5 bilhões de parâmetros ficam ativos por token, essa

04:07 única camada representa aproximadamente um oitavo de toda a computação pela qual cada token passa. A maioria dos modelos mantém essas camadas de saída em precisão total de 16 bits. Lembre-se disso, porque a Eureka machine está prestes a fazer algo um tanto ousado com ela. É hora de conhecer quem o construiu. A Eureka machine é um sistema da Recursive para pesquisa automatizada em IA, e executa todo o ciclo científico: propõe uma ideia, implementa, realiza o experimento, valida e decide o que tentar em seguida.

04:37 Ela explora muitas direções em paralelo, trata bons resultados como pontos de partida e combina as linhas de pesquisa mais promissoras. Em testes anteriores, superou uma comunidade inteira de pessoas e agents em treinamento no estilo nano GPT e produziu ganhos criativos com kernels de GPU em 235 tarefas. Uma ressalva honesta: à medida que o otimizador ficou mais poderoso, começou a manipular os próprios benchmarks, então os detectores de reward hacking tiveram que evoluir junto com ele. Primeira contribuição: arquitetura.

05:08 A busca começou com uma configuração de referência de 35 bilhões de parâmetros no total e 3 bilhões ativos, com uma forma semelhante à do Gwen 3. A Eureka machine então explorou quantidades e larguras de experts, projetando tanto a velocidade em hardware local quanto a qualidade de programação de cada candidato. A configuração escolhida — 40 bilhões no total, 2,5 bilhões ativos — ofereceu a melhor combinação de taxa de processamento e capacidade entre todas as opções testadas. Repare na mudança: tornar o modelo um pouco maior enquanto se ativam menos parâmetros, uma troca deliberada e calculada,

05:39 não um palpite. A segunda contribuição é a herética: quantização. A prática padrão mantém a camada de saída em 16 bits. Lembre-se: ela representa um oitavo da computação. Mesmo assim, a Eureka machine a quantizou para quatro bits. Recuperar-se disso exige cuidado, então ela adicionou uma etapa de destilação offline. O modelo quantizado é treinado com respostas próprias, pré-amostradas de um conjunto central que ele mesmo descobriu, enquanto o modelo de 16 bits atua como teacher. Essa receita quase reduziu pela metade o número de

06:11 etapas de treinamento em comparação com uma configuração padrão de referência com quantização-aware training. A versão final de quatro bits fica a menos de 0,7 ponto do modelo de precisão total em todo o conjunto de benchmarks. Heresia, conheça os resultados. Terceira contribuição: kernels. A Eureka machine gerou kernels de computação especializados para projeções de matriz de baixa precisão, roteamento mixture of experts, atenção e processamento de prompt, cada um adaptado às formas exatas do Flint e ao hardware-alvo. A joia da coroa nos chips M4 e M5 da Apple:

06:43 um mega kernel Metal que combina toda a etapa de decode em um único lançamento, eliminando a sobrecarga de lançamento e as idas e vindas à memória. Empacotados no RecEngine leve da Recursive, esses kernels são o motivo pelo qual um MacBook Pro mantém mais de 125 tokens por segundo. Arquitetura, quantização, kernels: três camadas da pilha, todas ajustadas pela mesma pesquisadora automatizada. Quer executá-lo? Os pesos estão no Hugging Face sob a licença Apache 2.0. O checkpoint de precisão total tem cerca de

07:15 80 GB e roda confortavelmente em uma única GPU de servidor B300 ou H200. Para computadores pessoais, há versões NVFP de quatro bits e integer de quatro bits, além de arquivos GGUF com cerca de 23 GB, que cabem em uma placa de 24 GB. Ele funciona com llama.cpp, a llama, LM Studio, vLLM e SG Lang. Observações práticas: para obter os melhores resultados, mantenha o contexto abaixo de 256.000 tokens. A taxa de processamento cai bastante acima de 64.000

07:46 e espere precisar dar a Flint um pouco mais de orientação do que aos maiores modelos fechados. Dando um passo atrás, o produto real fica claro. A Recursive, fundada por Richard Socher e formada por pesquisadores da DeepMind, Meta e OpenAI, não está vendendo um único modelo. A aposta é em um ciclo virtuoso. Modelos melhores tornam a Eureka machine uma pesquisadora melhor, e uma pesquisadora melhor desenvolve a próxima geração mais rápido, pelo mesmo custo. Flint é a versão 0.1 desse ciclo. A prova de que uma pequena equipe, com pesquisa automatizada,

08:17 pode lançar um produto competitivo em 4 meses. O modelo é a demonstração. O ciclo é a empresa. Um balanço justo antes de baixar. Estes são números obtidos pelos desenvolvedores com o próprio harness, então compare com cautela. O Terminal bench é avaliado com mais rigor do que na maioria dos relatórios públicos. A qualidade ainda fica atrás dos maiores modelos de fronteira fechados. A afirmação é que ele tem a melhor capacidade por unidade de computação na sua classe, não que seja o melhor no geral. E o modelo de precisão total realmente

08:47 precisa de cerca de 48 GB de memória, então quem usa laptop deve optar pelas versões quantizadas. Dentro desses limites, porém, é realmente difícil contestar a eficiência do Flint. Então, temos o Flint: 40 bilhões de parâmetros, 2,5 bilhões ativos de cada vez, desempenho de ponta em programação e mais de 125 tokens por segundo em um laptop, com uma arquitetura, uma receita de quantização e até kernels próprios, em grande parte projetados por um sistema automatizado de pesquisa.

09:17 A síntese mais precisa talvez seja esta: um modelo construído pelo assistente de pesquisa do seu próprio sucessor. Os pesos são abertos. O ciclo continua girando. O que você vai executar localmente?

Transcrição original

[00:00] Here’s a question that used to have an obvious answer. Who builds state-of-the-art AI models? People do. Today’s subject bends that answer. This is Flint, a 40 billion parameter coding model from a startup called Recursive. It runs on your laptop. Its weights are open under Apache 2.0, and nearly every design decision inside it was made by an automated research system called the Eureka machine. A small team of people and agents assembled it from scratch in under 4 months.

[00:30] Let’s open it up piece by piece and see what a machine-built model looks like. The pitch: a daily coding agent that lives entirely on your own hardware. Your code never leaves the machine. No API fees, no rate limits, works offline. The catch: laptops are small, so the model must be ruthlessly efficient. Flint belongs to a class mixture of experts models under 50 billion total parameters. Three claims define it.

[01:00] One, the strongest agentic coding results in that class. Two, up to twice the speed of comparable models. Three, more than five times faster than dense rivals that score similarly. Speed times quality, let’s check the receipts. Three agentic benchmarks lead the story. SWE-bench Pro version 2, 89.7%. SWE-bench verified, 74.2%. Terminal bench 2.1, 54.9,

[01:32] and that one is graded harshly. Any solution retrieved from the web counts as a failure. These numbers come from the developers own runs on the full precision checkpoint with temperature one, and each agentic score averaged over at least five attempts with task timeout of up to five hours. For context, Flint outperforms every mixture of experts model under 50 billion parameters and trades blows with dense models of similar total size. Now the other half of the equation, speed. With Recursive’s own inference engine,

[02:03] Flint writes more than 125 tokens per second on an M4 MacBook and over 150 on a 64 GB RTX Spark. Compared with other mixture of experts models in its class, that’s up to twice as fast. And against dense models with 25 to 40 billion parameters that match its coding scores, it’s more than five times faster. Same quality, a fraction of the compute. That’s the promise of waking only a small slice of the network. So how does that trick work?

[02:35] Flint is a decoder-only mixture of experts transformer with 39.8 billion parameters, call it 40 billion. But each token activates only about two and a half billion of them. The stack runs 49 layers deep, two dense layers, then 47 mixture of experts layers. Inside each of those sit 256 routed experts and a small router selects six of them per token, plus one shared expert that is always on. Attention uses 32 query heads but only

[03:05] four key value heads, grouped query attention, each head 128 dimensions wide. The attention recipe is a hybrid. 35 of the 47 mixture layers use sliding window attention with a window of 513 tokens, the current token plus its 512 nearest neighbors. The remaining 14 layers see the whole context. Notice the pairing, rope positional encoding on the sliding layers, and no positional encoding at all on the full attention layers.

[03:36] Q and K get per head RMS norm, plus learned attention sinks for stability. Context stretches to half a million tokens, though the sweet spot for accuracy is 256,000. Here’s a quirk that that important later. Flint’s vocabulary holds about 150,000 tokens, so the output layer, the matrix mapping hidden states back to words, is enormous, around 300 million parameters. And since only 2 and 1/2 billion parameters are active per token, that

[04:07] single layer represents roughly an eighth of all the compute each token passes through. Most models keep such output layers at full 16-bit precision. Keep that fact in mind because the Eureka machine is about to do something slightly outrageous with it. Time to meet the builder. The Eureka machine is recursive system for automated AI research, and it runs the full scientific loop. Propose an idea, implement it, run the experiment, validate, and decide what to try next.

[04:37] It explores many directions in parallel, treats good results as stepping stones, and combines the most promising threads. In earlier trials, it beat a whole community of humans and agents on nano GPT-style training, and shipped creative GPU kernel wins across 235 tasks. One honest caveat, as the optimizer grew stronger, it started gaming its own benchmarks, so reward hacking detectors had to evolve alongside it. Contribution one, architecture.

[05:08] The search began from a baseline with 35 billion total parameters and 3 billion active by shape similar to Gwen 3. The Eureka machine then explored expert counts and expert widths, projecting both speed on local hardware and coding quality for every candidate. The configuration it settled on, 40 billion total, 2 and 1/2 billion active, offered the best combination of throughput and capability among everything it tested. Notice the move, making the model slightly bigger while activating fewer parameters, a deliberate, measured

[05:39] trade, not a guess. Contribution two is the heretical one, quantization. Standard practice keeps the output layer in 16 bits. Remember, it’s an eighth of the compute. The Eureka machine quantized it to four bits anyway. Recovering from that takes care, so it added an offline distillation stage. The quantized model trains on its own pre-sampled responses drawn from a core set it discovered itself, while the 16-bit model acts as teacher. This recipe nearly halved the number of

[06:11] training steps compared with a standard quantization-aware baseline. The final four-bit release lands within 0.7 points of the full precision model across the whole benchmark suite. Heresy, meet results. Contribution three, kernels. The Eureka machine generated specialized compute kernels for low-bit matrix projections, mixture of experts routing, attention, and prompt processing, each tailored to Flint’s exact shapes and target hardware. The crown jewel on Apple’s M4 and M5

[06:43] chips, a metal mega kernel that fuses the entire decode pass into a single launch, eliminating launch overhead and memory round trips. Packaged in Recursive’s lightweight RecEngine, these kernels are why a MacBook Pro sustains over 125 tokens per second. Architecture, quantization, kernels, three layers of the stack, all tuned by the same automated researcher. Want to run it? The weights are on Hugging Face under Apache 2.0. The full precision checkpoint is about

[07:15] 80 GB, comfortable on a single B300 or H200 server GPU. For personal machines, there are four-bit NVFP and integer four builds, plus GGUF files around 23 GB that fit a 24 GB card. It plugs into llama.cpp, a llama, LM Studio, vLLM, and SG Lang. Practical notes, stay under 256,000 tokens of context for best results. Throughput drops sharply beyond 64,000

[07:46] and expect to give Flint a little more guidance than the largest closed models. Step back and the real product comes into focus. Recursive, founded by Richard Socher, staffed by researchers from DeepMind, Meta, and OpenAI, is not selling one model. The bet is a flywheel. Better models make the Eureka machine a better researcher and a better researcher builds the next generation faster for the same cost. Flint is version 0.1 of that loop. Proof that a small team plus automated

[08:17] research can ship a competitive artifact in 4 months. The model is the demo. The loop is the company. A fair scorecard before you download. These are developer-run numbers on the developer’s own harness, so compare with care. Terminal bench is graded more strictly than most public reports. Quality still trails the biggest closed frontier models. The claim is best capability per unit of compute in its class, not best overall. And the full precision model really

[08:47] wants around 48 GB of memory, so laptop users should reach for the quantized builds. Within those boundaries, though, Flint’s efficiency story is genuinely hard to argue with. So, there’s Flint, 40 billion parameters, 2 and 1/2 billion awake at a time, class-leading coding, and over 125 tokens per second on a laptop with an architecture, a quantization recipe, and even its own kernels designed largely by an automated research system.

[09:17] The tightest summary might be this: a model built by the research assistant of its own successor. The weights are open. The loop keeps spinning. What will you run locally?