Flint: vale trocar o Qwen 35B por esse modelo americano de 40B?

Autoria: AI ProgBr · 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: vale trocar o Qwen 35B por esse modelo Americano de 40B? · Canal: AI ProgBr · 18:50 · Assistir no YouTube

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

Resumo

O vídeo apresenta Flint, um modelo open source de 40 bilhões de parâmetros da Recursive AI, baseado em uma arquitetura MoE e voltado para uso em agents. O apresentador compara seus resultados com outros modelos e testa versões quantizadas em um Mac, observando diferenças de desempenho entre engines e problemas de compatibilidade. Nos testes, Flint resolve um problema de instalação e gera tokens rapidamente, mas a velocidade cai conforme cresce o context window, tanto na geração quanto no processamento do prompt. A conclusão é que o modelo mostra potencial para tarefas agentic, mas ainda precisa de mais testes para saber se pode substituir o Qwen 35B.

Pontos-chave

Flint tem 40 bilhões de parâmetros, dos quais cerca de 2,5 bilhões são ativados, com seis experts ativados por token.
O modelo foi desenvolvido pela Recursive AI em quatro meses, treinado do zero e disponibilizado com pesos abertos sob uma licença 2.0.
Há versões em diferentes formatos e quantizações, incluindo opções voltadas para Mac e GPUs Nvidia.
No Mac M3 Ultra, o apresentador mediu cerca de 90 tokens por segundo no LM Studio e até 130 tokens por segundo com outra engine em contexto menor.
A engine testada tinha uma restrição de instalação que excluía o M3 Ultra e até o M4 Max; Flint ajudou a identificar e corrigir o problema.
Em uma tarefa de processamento de mais de 100 mil tokens, a velocidade foi de 749 tokens por segundo, mas a geração caiu quando o context window aumentou.
O apresentador vê potencial para Flint em tarefas com agents, mas considera que ainda são necessários mais testes antes de compará-lo como substituto do Qwen 35B.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação de Flint	O apresentador introduz Flint, sua arquitetura MoE, a empresa responsável e os dados de benchmark disponíveis.
03:07	Desenvolvimento, pesos abertos e harness	O vídeo aborda o treinamento do modelo, sua licença e a importância do harness para tornar o comportamento mais previsível.
04:10	Versões e execução local	O apresentador compara formatos e quantizações e inicia um teste de Flint no Mac usando LM Studio.
09:24	Engine alternativa e problema de instalação	O vídeo examina uma engine que promete mais velocidade e investiga suas restrições de compatibilidade com Macs.
12:01	Flint corrige a instalação e é testado como agent	Com OpenCode, Flint identifica e corrige o bloqueio de instalação, e então é testado em tarefas com um context window carregado.
15:42	Processamento de prompt e efeito do contexto	O apresentador mede o processamento de textos longos e mostra como o aumento do context window reduz o desempenho.
17:16	Potencial e conclusão	O apresentador avalia o potencial de Flint em tarefas agentic e deixa em aberto se ele poderá substituir o Qwen 35B.

Citações

Hoje vamos conhecer o novo modelo open source americano chamado Flint. — 00:00

O segredo foi criar um harness grande, a Eureka Machine, que automatizou todo o processo. — 03:07

Você comete mais erros, só que mais rápido. — 07:47

À medida que o context window cresce, a velocidade de desempenho do modelo cai bastante. — 16:14

É um modelo que espero muito que seja bom. — 17:16

Conceitos e entidades

Flint (modelo): Modelo MoE de 40 bilhões de parâmetros apresentado e testado no vídeo.
Recursive AI (empresa): Empresa de San Francisco responsável pelo desenvolvimento de Flint.
Mixture of Experts (conceito): Arquitetura que ativa apenas parte dos parâmetros do modelo durante o processamento.
Eureka Machine (ferramenta): Harness criado pela Recursive AI para automatizar o processo de desenvolvimento do modelo.
LM Studio (ferramenta): Aplicativo usado pelo apresentador para baixar e executar uma versão quantizada de Flint.
llama.cpp (ferramenta): Engine mencionada como uma das opções para executar Flint localmente.
MLX (ferramenta): Framework citado como uma opção de execução de modelos em computadores Mac.
OpenCode (ferramenta): Ferramenta usada junto com Flint para investigar e corrigir o problema de instalação.
Qwen 35B (modelo): Modelo de 35 bilhões de parâmetros usado como referência na pergunta sobre substituir Flint.
Mac M3 Ultra (ferramenta): Computador usado pelo apresentador para testar a velocidade de Flint.

Tradução completa (pt-BR)

00:00 Hoje vamos dar uma olhada no novo modelo open source americano chamado Flint. Vamos para a tela para eu mostrar um pouco para vocês. Vamos lá. O que é o Flint? Flint é um novo modelo de 40 bilhões de parâmetros de uma empresa americana sediada em San Francisco. E, apesar de ter 40 bilhões de parâmetros, ele é um MoE, uma mistura de experts. Isso significa que ele não ativa todos os parâmetros de uma vez. Ele ativa cerca de 2,5 bilhões de parâmetros, o que o torna muito mais rápido do que modelos densos de 40 bilhões de parâmetros. E vou dizer que eu esperava algo desse

00:31 tamanho, porque, se fôssemos quantificá-lo, teríamos um total de cerca de 20 GB. E 20 GB seriam ideais para Macs com um pouco mais de memória; 48 GB já seriam suficientes para carregar esse modelo. E também os novos RTX Sparks, que são, na verdade, os principais alvos da Recursive AI, ou Recursive Sai, não sei, estou mudando tudo para ESI. Certo, então a Recursive é a empresa por trás do Flint. E o Flint foi projetado especificamente para rodar em agents. Ele tem 256 experts

01:01 e ativa seis deles para cada token, mas às vezes comete erros, certo? Porque podemos ver aqui que ele tem uma context window de 513.000 tokens, o que está errado. Na verdade, a context window dele é de 262.000 tokens. Aliás, isso é um spoiler, né? Esta apresentação foi feita com o Flint. Aqui temos alguns dados de benchmark. No Terminal Bench 2.1, ele marcou 54,9 pontos. No SWE Bench Pro V2, 89,7, e no SWE Bench Verified, 74,2. É interessante

01:35 ter esses dados aqui na apresentação, mas, sem contexto e sem um parâmetro de comparação, eles perdem um pouco do significado. Então vamos ao nosso gráfico de benchmark para termos uma ideia melhor. Aqui temos o Qwen. Com 6,35 bilhões de parâmetros, nessa faixa ele ainda é o absoluto campeão. Mesmo tendo outros modelos que foram treinados com base nele, na prática acabo preferindo-o. Vamos ver se será diferente com o Flint, porque, em vários benchmarks, o salto é considerável. Mas isso

02:05 não acontece em todos os benchmarks. Em alguns, sim, mas aqui a diferença já é muito pequena. E aqui ele fica até atrás. Agora, outro dado interessante é que a versão NVFP4 obteve uma pontuação maior do que a versão de 16 bits, pelo menos aqui no Live Code Bandwidth. Nos outros, os resultados foram muito, muito próximos, com cerca de um ponto de diferença, não muito mais do que isso. Obviamente, outro modelo que estamos sempre acompanhando, o absoluto campeão abaixo de 30 bilhões de parâmetros, é o Qwen 3 8 27B, que o nosso Flint não consegue superar em praticamente nenhum benchmark aqui. Só nestes dois ele tem um desempenho um pouco melhor, certo? São os dois IFFs, mas em todos os outros o 27B vence. Um dado interessante sobre esse modelo é que levou quatro meses para desenvolvê-lo e ele foi treinado do zero, passando por todo o processo: pré-treinamento, treinamento, supervisão e aprendizado por reforço, tudo feito pela Recursive. E o segredo aqui foi terem criado um grande harness, a Eureca Machine,

02:37 27B, que o nosso Flint não consegue superar em praticamente nenhum benchmark aqui. Só nestes dois ele tem um desempenho um pouco melhor, certo? Estes são os dois IFFs, mas, em todos os outros, o 27B vence. Um fato interessante sobre este modelo é que levou 4 meses para ser desenvolvido e foi treinado do zero, passando por todo o processo: pré-treinamento, treinamento, supervisão, aprendizado por reforço, tudo feito pela Recursive. E o segredo aqui foi que eles criaram um harness grande, a Eureca Machine,

03:07 que basicamente automatizou tudo, o processo inteiro. Além disso, esse modelo tem pesos abertos e uma licença 2.0. Isso significa que você pode rodá-lo localmente, pode até modificá-lo, redistribuí-lo; pode fazer o que quiser. E ele até faz um pouco de autopromoção, porque, no último slide, lançou um curso “quer dominar a IA?” no aaiprobr.com. O link estará na descrição. É o meu curso de desenvolvimento de IA. E ele fez isso porque está usando uma skill que estou desenvolvendo. Na verdade, se você acessar aaiprobr.com, vai ver que o estilo do nosso slide é exatamente o estilo da

03:39 nossa página aqui. E isso não é por acaso; é por causa de uma skill. E esse talvez seja um dos maiores segredos. Na verdade, não é segredo nenhum, mas muita gente não sabe disso, certo? Quem é aluno do meu curso sabe que, se você entende o que está fazendo, entende o harness e entende como estrutura tudo em torno do modelo, deixa o modelo mais determinístico, menos solto. Em outras palavras, mesmo que você troque o modelo, pode fazê-lo se comportar de maneira previsível. E foi exatamente isso que fiz aqui com esta apresentação. Então, se você

04:10 tem interesse em desenvolver com IA, dê uma olhada no meu curso. Agora, vamos dar uma olhada no Hugging Face, porque eles lançaram quatro versões do Flint. A primeira é a versão de 16 bits, com 78 GB. Então, se quiser rodar este modelo, vai precisar de mais de 80 GB de VRAM ou memória unificada. Mas já aviso: embora ele seja um MoE, uma mistura de experts, quando chegamos a esse tamanho, com o hardware que temos hoje com memória unificada — estou falando dos Macs M3, M4, M5 e também do DJX Spark e do RTX Spark, que também são computadores

04:41 com memória unificada —, costumo mencionar esses dois e me esqueço da AMD; também há a AMD. Aliás, se alguém da AMD tiver um e quiser nos enviar para testarmos aqui, vamos testá-lo. Mas enfim, todos esses hardwares vão funcionar bem com mistura de experts, mas normalmente são os modelos de mistura de experts mais quantizados. E é exatamente por isso que eles lançaram outras quatro versões de 4 bits, porque a ideia é realmente rodá-lo localmente. Então temos um intgfodar aqui no Llama CPP, feito para rodar no Mac, mas normalmente no Mac vamos rodar melhor com MLEX

05:11 . Também temos este INT 4, que será um formato MLEX para rodar no Mac. Já em placas da Nvidia, no RTX Spark ou em outras placas, o NVFP4 será a melhor opção disponível. Mas, claro, se formos até aqui, em Quantities, já temos as quantizações da comunidade; há o Dancelot aqui, com todos os tamanhos que você quiser. Então, se você tem uma placa de 16 GB, pode rodar um Q2 tranquilamente. Talvez não com todo o

05:43 contexto, mas é possível rodá-lo. Como é uma mistura de experts, você pode descarregá-lo na RAM e ainda ter uma velocidade utilizável. Mas, enfim, para facilitar minha vida, qual foi a primeira coisa que fiz? Fui ao LM Studio, baixei a versão deles, uma versão Q6 do Flint, para rodar aqui no meu Mac M3 Ultra. Com ele carregado aqui, vou pedir para ele responder, para termos uma ideia da velocidade. E olha só: 90 tokens por segundo. Nada mal. Vou pedir algo um pouco mais elaborado para vermos essa velocidade em um texto mais longo. Por exemplo, vamos perguntar a ele

06:15 se um disco rígido que roda bem LLMs necessariamente também vai rodar bem modelos de imagem. A resposta é não. Certo? Vamos ver o que ele vai dizer aqui. Ele deu uma resposta um pouco mais longa e, na minha opinião, incorreta, porque, quando estamos rodando modelos de LLM, a largura de banda se torna muito importante, principalmente se estivermos falando de modelos classificados como densos. Também há um ponto importante relacionado ao poder de processamento, que é o processamento do prompt. Depois que o prompt é processado e totalmente armazenado em cache, você pode reutilizá-lo muito rapidamente,

06:45 e então, basicamente, todo o processo se resume à largura de banda disponível e à velocidade da memória. Assim, você pode ter um hardware que não tenha uma capacidade de processamento tão grande, mas que tenha uma largura de banda excelente, e ele vai rodar modelos de LLM com bastante eficiência. É o caso do Mac. Ele não é tão bom no processamento do prompt nem na geração de imagens, mas é bom na geração de tokens. Quando passamos para a geração de imagens, o poder de processamento se torna muito mais importante do que a capacidade de largura de banda. Então podemos usar uma largura de banda menor e ter um poder de processamento maior, e assim

07:16 gerar imagens muito mais rapidamente. Por exemplo, para gerar imagens, áudio e outras coisas, o RTX Spark será mais rápido do que o Mac. Isso vai mudar, porque os Macs vão melhorar e terão mais capacidade de processamento. O M5 Ultra gera imagens quatro vezes mais rápido do que o M3 Ultra, mas tem apenas 50% mais largura de banda. Em outras palavras, uma coisa não tem relação direta com a outra. Resposta errada. Mais rápido, né? 91 tokens por segundo. Em outras palavras, você

07:47 comete mais erros, comete erros mais rápido; melhor ou não, não sei. Bem, se a alternativa for acertar devagar, talvez acertar devagar seja melhor. Mas, se tiver que errar, erre devagar; isso é bom. Melhor errar rápido. No entanto, mesmo com 91 tokens por segundo, não gosto dessa velocidade. Vou explicar por quê. Richard, que é o CEO aqui da Recurse VII, Recur VSI, seja lá o que for, está dizendo na publicação de apresentação do Flint que consegue chegar a até 125 tokens por segundo no MacBook

08:18 Pro. E mais abaixo podemos entender que esse MacBook Pro é o M4 Pro, não o M4 Max nem o M5 Max: é o M4 Pro. Não aceito, não aceito que o M3 Ultra seja mais lento que o M4 Pro. E há alguns detalhes aqui, certo? Como expliquei, para a geração de tokens, a largura de banda é o fator mais importante. A largura de banda do M4 Pro é de 273 GB/s, enquanto a do M3 Ultra é de 809 GB/s. Então, ele não pode ser

08:53 mais lento, mas é. E então vocês se lembram de que lançaram quatro modelos diferentes? llama.cpp não é a maneira mais rápida de executar um modelo em um Mac. O MLX normalmente será mais rápido, embora, historicamente, as versões Q4 do MLX costumem apresentar certo grau de perda de qualidade quando são executadas. Não entendi muito bem por que lançaram aqui uma versão 24, mas tudo bem. Esta aqui seria a versão feita em MLX para rodarmos no Mac. Mas

09:24 há outro porém aqui. Indo daqui até ali, cheguei a este repo, o repo do Flint. Em comparação com o llama.cpp, o Flint oferece uma velocidade de tokens por segundo de 1,4 a 2,6 vezes maior. Então, ele atingiu esses valores usando seu próprio mecanismo, em vez de usar apenas o llama.cpp, que era o que estávamos usando no software LM Studio. Aí eu disse: “Vou instalar”. Mas tive um pequeno

09:54 problema. E o problema está nesta linha aqui. Os requisitos para usar o Flint são ter um Mac com chip M4 Pro, M5 Pro ou M5 Max. O que isso significa? Essa frase significa que o M3 Ultra não é compatível com o Flint. Isso não faz sentido. Você pode pensar: “Não, Igor, ele só é compatível com o M4 em diante”. Mas é pior do que isso. O que acontece? Do M3 para o M4, não houve nenhuma grande mudança arquitetônica. Do M4 para o M5, houve uma pequena mudança arquitetônica

10:26 Do M5 para o M6, temos uma mudança arquitetônica significativa. Isso significa que, sim, ele rodaria no M6, mas não em nenhum modelo anterior. Como o M5 já vem com ANE, ele até rodaria no M5, mas não no M4; só que, se roda no M4, não há motivo para não rodar no M3. Agora vocês já podem estar prontos para escrever: “Ah, Igor, você está maluco? Não sabe do que está falando”. Então vou mostrar para vocês. Vou mostrar algo que vai deixar vocês sem palavras. Lembrem-se disto: M4 Pro,

10:58 M5 Pro, M5 Max. São esses os modelos que estão escritos aqui. E, como eu disse, para esses caras, o que está escrito é lei, porque eles são malucos. Se subirmos aqui e clicarmos aqui, olha: suporte para M4 Max. O M4 Max é melhor que o M4 Pro. Se roda no M4 Pro, não há motivo para não rodar no M4 Max. Mas, quando você tenta instalar isso no M4 Max, olha o que acontece aqui. O Flint exige que você tenha um Apple

11:29 com M4 Pro, M5 Pro ou M5 Max. Detectamos um M4 Max, então não é possível. Nunca vi isso na vida. O que está acontecendo? Isso é loucura. Vocês percebem? E não estou reclamando, não, certo? É algo que eu definitivamente faria. Minhas soluções improvisadas por aí. Mas, vamos lá, pessoal, qual é a dessa? Bem, quando chegamos a esse obstáculo, só há uma coisa a fazer. Se estou testando o Flint, será que o Flint vai resolver isso? E vou dar um spoiler para vocês. Vou digitar aqui: “

12:01 flint doctor”. E temos aqui, olha, não parou, certo? Diferente do que aconteceu no M4 Max da pessoa que está tentando abrir aquilo ali. Por quê? Porque baixei o projeto e pedi ao Flint para resolver isso para mim. Na primeira vez que tentei instalar, apareceu exatamente a mesma mensagem, só que no final dizia M3 Ultra, que é a máquina em que estou executando. Então peguei o Flint, que estava rodando no LM Studio, juntei com o Open Code para identificar qual era o problema e corrigi-lo. Ele

12:32 identificou o problema e o corrigiu. E agora podemos executar nosso Flint aqui. Agora só preciso digitar “launch open code” na pasta que quero abrir, e ele vai iniciar o Flint e… vai abrir a janela do Open Code para nós. Ótimo, já está aberta aqui. Antes de digitar qualquer coisa, ainda não superei isso. Vamos voltar aqui rapidinho. Acabei de mostrar esse problema, mas a pior parte é a resposta. Olha, alguém perguntou aqui: “Flint Doctor, está bloqueando a instalação no meu M4 Max. Quando posso esperar suporte para o Max?” A

13:04 resposta foi: “Obrigado pela pergunta. Ainda não testamos no M4 Max. Estamos investigando e vamos atualizar isso.” O quê? Meu Deus, funciona no M4 Pro. Tudo bem, já chega. Certo, certo. Vamos voltar aqui. Vou cumprimentar nosso modelo. Oi, tudo bem? Olha, no primeiro prompt, 10 tokens por segundo. Agora vou pedir para ele contar uma história. Assim, mais rápido. 83 tokens por segundo. Mas espera, 83 tokens por segundo

13:35 é menos que 90. O que aconteceu? Bem, aconteceu um pequeno problema chamado context window. Então, aqui no Open Code, olha, já temos 11 mil tokens na nossa context window. Isso vem do system prompt, das skills que estão carregadas, com os cabeçalhos das skills. Quem é aluno do meu curso sabe exatamente do que estou falando, mas, basicamente, esse comportamento é esperado, especialmente com esse mecanismo, com esse modelo, pelo menos por enquanto. A comunidade provavelmente vai mexer ainda mais nesse mecanismo para deixá-lo melhor do que já é. Quer dizer,

14:07 se esse modelo se mostrar realmente bom, certo? Nos meus testes, ele já deu um primeiro passo, porque resolveu para nós o problema do M3 Ultra. Então, ele é de fato capaz de agir como um agent e é inteligente o suficiente para identificar um problema e seguir adiante para resolvê-lo. Mas até mesmo na documentação do mecanismo vemos esse comportamento acontecer, certo? Este é o gráfico de velocidade em relação ao tamanho do contexto. Então, na verdade, ele começa perto de 125 tokens. Isso é no M4 Pro. Mas, com 8 mil tokens, já cai para menos de… 100. Está vendo aqui? Com

14:40 11 mil tokens, ficaria em torno de 90 tokens. O problema é que esses 90 tokens deveriam ser no M4 Pro; eu estou no M3 Ultra, então deveria ser mais rápido. Por algum motivo, isso não está acontecendo. E, para conseguirmos ver um pouco melhor a velocidade sem a context window cheia, vou usar esta ferramenta aqui. Vou dar oi aqui para começarmos a observar isso. Pronto. Chegamos a 130 tokens por segundo. Agora estamos falando a minha língua. Mesmo assim, ainda não é suficiente, certo? O M4 Pro chegou a 125. Este aqui, com três vezes mais largura de banda, deveria ser muito mais rápido. E acho que pode ser. Mas vamos precisar modificar o Zendnis. Alguém vai fazer isso em breve. Talvez seja eu, talvez não. Vamos pedir para alguém escrever um pouco de código aqui. Crie uma cópia do Flapbird. E então quero ver quanto tempo ele vai levar aqui para… Ele decidiu escrever tudo. Decidiu fazer isso em Python. Certo? 117 tokens por segundo. Foram gerados 2 mil tokens no total. Certo. É uma boa velocidade. Mas, para uma mistura de especialistas com 2 bilhões de parâmetros ativos, menos de 3 bilhões de parâmetros ativos, eu

15:11 esperava um pouco mais. Sei que já disse isso várias vezes, vou parar de repetir, mas era o que eu esperava. Agora, o próximo teste que precisamos ver, deixa eu atualizar aqui só para limpar tudo, é o processamento do prompt. Então vou pedir para ele resumir este texto aqui em um parágrafo, que é bem longo, certo? Vamos ver quanto tempo ele leva. Olha, aqui está o resultado. Foram processados mais de 100 mil tokens. Levou 135 segundos, ou seja, 2 minutos e 15 segundos. E a taxa foi de 749 tokens por segundo. Aqui, com esse nível de contexto preenchido,

15:42 a velocidade caiu consideravelmente. Foi de mais de 100 tokens por segundo para 37 tokens por segundo para escrever este resumo. Isso significa que, se você estiver usando o modelo de forma programática dentro de um agent, à medida que o tamanho da janela aumenta, a velocidade de desempenho do modelo vai cair bastante. E aqui estamos falando tanto dos tokens por segundo quanto do processamento do prompt, porque, se pegarmos só metade deste livro aqui, um pouco menos, apenas este trecho aqui, e pedirmos para ele resumir, ele processou

16:14 .

16:44 em 5 segundos. Vamos ver quantos tokens: um total de 8.000 tokens em 5 segundos. Então, a taxa aqui já é de 1.500 tokens por segundo. Quando aumentamos o contexto, o processamento do prompt também cai. E, claro, como estávamos dizendo, a geração de tokens acompanha essa queda, certo? 99 tokens por segundo, porque a context window é pequena. Você deve estar pensando: “Igor, você não vai fazer um jogo?” Bem, neste vídeo eu queria falar mais sobre velocidade e coisas do tipo. Porque, bom, não acho que você vá.

17:16 Não é adequado para criar jogos. Quero fazer mais testes com esse modelo, mas acho que jogos não são o seu forte. Provavelmente, ele terá um desempenho melhor em tarefas como pilotar o Leon Hermes e em tarefas agênticas em geral. Tenho muita esperança de que esse modelo seja muito bom. Ainda preciso fazer mais alguns testes. Hoje, ele conseguiu fazer nossa apresentação e conseguiu ajustar o INne, certo? Mas não foi um ajuste muito complicado; ainda assim, conseguiu. Conseguiu ajustá-lo para podermos instalar o hack. Agora, provavelmente em breve teremos MTP para esse modelo, que é

17:48 algo que ainda não temos. Então, essas velocidades vão aumentar, e é sempre bom ter mais algumas alternativas, certo? Um modelo com 40 bilhões de parâmetros não aparece todo dia. Então, se ele pudesse substituir o Qwen de 35 bilhões de parâmetros, seria muito legal, certo? Tomara que a equipe da Alibaba lance o Qwen 4 com 35 bilhões de parâmetros, uma mistura de especialistas, ou até um pouco mais ou um pouco menos, porque tenho certeza de que, se vocês lançarem, vai ser incrível e será difícil para as pessoas chegarem lá. Ninguém chegou ao 3.5 ainda, eu acho que

18:18 este também não chegou, mas quero experimentar mais. Se você já está experimentando o Flint, deixe um comentário abaixo contando os resultados que está obtendo e o que está funcionando para você. Quero usá-lo mais e acho que ele vai dar conta de algumas das coisas que quero fazer. Se quiser ver a gente executando alguns modelos aqui na outra configuração, com duas Arc B70s, confira este link aqui. E também, se quiser ver o Flint, deixe um comentário abaixo para a gente. Se quiser ver o DeepSeek mais recente, também fizemos um vídeo sobre ele no canal; é só clicar aqui. Agora, se quiser entender completamente como o desenvolvimento de IA funciona de verdade, não deixe de clicar

18:50 neste link aqui. Assim, você vai aprender a criar suas próprias skills, entre muitas outras coisas. Mas o que quero dizer é que você não vai depender de alguma skill mágica ou de algo mágico para resolver seus problemas, nem de um modelo cujo preço pode dobrar amanhã. Você vai saber se… Ele pode até se transformar em modelos como o Flint. Vou ficando por aqui; até o próximo vídeo.

Transcrição original

[00:00] Today we’re going to take a look at the new American open model called Flint. Let’s go to the screen so I can show you a little bit. Let’s go then. What is Flint? Flint is a new 40 billion parameter model from an American company based in San Francisco. And despite having 40 billion parameters, it’s a MOE, a mixture of experts. This means that it doesn’t activate all parameters at once. It activates around 2.5 billion parameters, which makes it much faster than dense 40 billion parameter models. And I will tell you that I was expecting something of this

[00:31] size, because if we were to quantify it , we would have a total of around 20 GB . And 20 GB will be ideal for Macs with a little more memory; 48 GB would already be enough to load this model. And the new RTX Sparks too, which are actually the main targets of Recursive AI or Recursive Sai, I don’t know, I’m changing everything to ESI. Okay, so Recursive is the company behind Flint. And Flint was specifically designed to run within agents. It has 256 experts

[01:01] and activates six of them for each token, but sometimes it makes mistakes, okay? Because we can see here that it has a context window of 513,000 tokens, which is wrong. In fact, its context window is 262,000 tokens. By the way, that’s a spoiler, right? This presentation was done with Flint. Here we have some benchmark data. Terminal Bench 2.1, it scored 54.9 points. In SW Bench Pro V2, 89.7, and in SW Bench Verified, 74.2. It’s interesting to

[01:35] have this data here in the presentation , but without context, without a comparison parameter, it loses some meaning. So let’s go to our benchmark graph so we can get a better idea. So here we have Quent. With 6.35 million parameters, in that range, it’s still the absolute king. Even though we have other models that were trained on it, in practice I end up preferring it. Let’s see if it will be different with Flint, because in several benchmarks, the jump is considerable. But this

[02:05] doesn’t happen in all benchmarks. In some, yes, but here, it’s already a very small difference. And here it even falls behind. Now, another interesting fact is that the NVFP4 version achieved a higher score than the 16-bit version, at least here in Live Code Bandwidth. In the others, it was very, very close, with about one point difference, not much more than that. Obviously, another model that we’re always keeping an eye on, which is the absolute king below 30 billion parameters, is the Quentas 8

[02:37] 27B, which our Flint can’t beat in practically any benchmark here. Only in these two does it perform a little better, right? These are the two IFFs, but in all the others, 27B wins. An interesting fact about this model is that it took 4 months to develop and it was trained from scratch, going through the entire process: pre-training, training, supervision, reinforcement learning, all done by Recursive. And the secret here was that they created a large harness, the Eureca Machine,

[03:07] which basically automated everything, the whole process. Plus, this model has open weights and a 2.0 license. That means you can run it locally, you can even modify it, redistribute it, you can do whatever you want. And he even does some self-promotion, because in the last slide he launched a “want to master AI” course on aaiprobr.com. The link will be in the description. It’s my AI development course. And he did this because he’s using a skill I’m developing. In fact, if you go to aaiprobr.com, you’ll see that the style of our slide is exactly the style of

[03:39] our page here. And that’s not by chance , it’s due to skill. And that’s perhaps one of the biggest secrets. Actually, it’s not a secret at all, but many people don’t know it, okay? Those who are students in my course know that if you understand what you’re doing, you understand the harness, you understand how you structure everything around the model, you make the model more deterministic, less loose. In other words, even if you change the model, you can make it behave in a predictable way. And that’s exactly what I did here with this presentation. So, if you’re

[04:10] interested in developing with IAR, take a look at my course. Now, let’s take a look at Hugin Face, because they released four versions of Flint. The first is the 16-bit version with 78 GB. So if you want to run this model here, you’ll need more than 80 GB of V or unified memory. But I’ll warn you right now: even though it’s MOI (mixture of experts), when we get to this size level, with the hardware we have today with unified memory—I’m talking about Macs M3, M4, M5, and also DJX Spark, RTX Spark, which are also computers

[04:41] with unified memory—I usually mention these two, forgetting about AMD; there’s AMD too. By the way, if anyone from AMD has one and wants to send it to us to test here, we’ll test it. But well, all these Harders will be good with mixture of experts, but normally they are the more quantized mixture experts. And that’s exactly why they released other 4-bit versions here, because the idea is to actually run it locally. So we have an intgfodar here in Llama CPP, which was made to run on Mac, but normally on Mac we’ll run MLEX

[05:11] better. We also have this INT 4, which will be an MLEX format to run on Mac. Now, on Nvidia, RTX Spark, or other cards, the NVFP4 will be the best available option. But of course, we also have, if we go here, in Quantities , we already have the community Quantizations, there’s Dancelot here, with all the sizes you want. So, if you have a 16GB card, you can run a Q2 smoothly. Maybe not with all the

[05:43] context, but it’s possible to run it. Since it’s a mixture of experts, you can offload it to RAM and still have usable speed. But well, to make my life easier, what was the first thing I did? I came to LM Studio, downloaded their version, a Q6 version of Flint to run here on my Mac M3 Ultra. With it loaded here, I’ll give you a shout so we can get an idea of the speed. And look, 90 tokens per second. Not bad at all. Let me ask for something a little more elaborate so we can see this speed in a longer text. For example, let’s ask him

[06:15] if a hard drive that runs LLMs well will necessarily run image models well? The answer is no. Okay? Let’s see what he’ll say here. So he gave an answer that is a bit longer and, in my view, incorrect, because when we are running LLM models, the bandwidth becomes very important, particularly if we happen to be discussing models that are classified as dense. There’s also an important point in processing power, which is for processing the prompt. Once the prompt is processed and fully cached, you can reuse it very quickly,

[06:45] and then basically the entire process comes down to the available bandwidth and the speed of the memory. So you may have hardware that does not have such great processing capacity, but with excellent bandwidth, and it will run LLM models quite effectively. This is the case with the Mac. It’s not that good at either prompt processing or image generation, but it’s good at token generation. When we move over to image generation, then the processing power becomes much more important than the bandwidth capacity. So we can utilize low bandwidth while having higher processing power, and then

[07:16] generate images much more rapidly. For example, if you take image, audio, etc. generation, RTX Spark will be faster than on the Mac. This will change because Macs will get better, they will have more processing capacity. The M5 Ultra generates images four times faster than the M3 Ultra, but it only has 50%more bandwidth. In other words, one thing has no direct relation to the other. Wrong answer. Faster, right? 91 tokens per second. In other words, you

[07:47] make more mistakes, you make faster mistakes, better or not, I don’t know. Well, if we think that the alternative would be to get it right slowly, maybe getting it right slowly is better. But if you must err, then err slowly; that is good. Better to get it wrong quickly . However, even with 91 tokens per second, I don’t like that speed. Let me explain why. Richard, who is the CEO here at Recurse VII, Recur VSI, whatever, he’s saying in Flint’s introductory post that he can run up to 125 tokens per second on the MacBook

[08:18] Pro. And further down we can understand that this MacBook Pro is the M4 Pro, not the M4 Max or the M5 Max, it’s the M4 Pro. I don’t accept, I don’t accept that the M3 Ultra is slower than the M4 Pro. And there are some details here, right? As I explained, for token generation, bandwidth is the most important factor. The M4 Pro’s bandwidth is 273 GB/s, while the M3 Ultra’s is 809 GB/s. So it can’t be

[08:53] slower, but it is slower. And then you remember here, they released four different models? Lama CPP is not the fastest way to run a model on a Mac. MLX will typically be faster, although historically, the Q4 versions of MLX usually exhibit a certain degree of quality loss when you run them. I didn’t quite understand why they released a version 24 here, but okay. This one here would be the version, made in MLX for us to run on Mac. But

[09:24] there’s another catch here. Going from here to there, I arrived at this repository here, the repository of the hack. Compared to Lama CPP, the hack delivers 1.4 to 2.6 times more token speed per second than Lama CPP. So it achieved those values using its own engine, rather than pure Lama CPP, which is what we were using inside of the LM Studio software. And then I said , I’ll install it. But I had a small

[09:54] problem. And the problem is in this line here. The requirements for using the hack are that you have a Mac with an M4 Pro, M5 Pro, or M5 Max chip. What does this mean? This sentence means that the M3 Ultra is not compatible with the hack. This makes no sense. You might think, “No, Igor, it’s only compatible with the M4 and above.” But it’s worse than that. What happens? From the M3 to the M4 there wasn’t any major architectural change. From the M4 to the M5 there’s a small architectural

[10:26] change. From the M5 to the M6 we have a significant architectural change. This means that yes, it would run on the M6 and not on anything previous. Since the M5 already comes with ANE, it would even run on the M5 and not on the M4, but once it runs on the M4, there’s no reason why it wouldn’t run on the M3. Now you can be ready to type, Igor: “Ah , are you crazy? You don’t know what you’re talking about. So I’ll show you. I’ll show you something that will leave you speechless. Remember this: M4 Pro,

[10:58] M5 Pro, M5 Max. These are the ones written here. And as I told you, what’s written is law for these guys, because they’re crazy. If we go up here and click here, see, support for M4 Max, the M4 Max is better than the M4 Pro. If it runs on the M4 Pro, there’s no reason why it shouldn’t run on the M4 Max. But when you try to install this on the M4 Max, look what happens here. Flint requires you to have an Apple

[11:29] with M4 Pro, M5 Pro or M5 Max. We detected M4 Max, so it can’t. I’ve never seen this in my life. What happens? This is crazy. Do you realize this? And I’m not complaining, no, Okay ? It’s something I would definitely do. My makeshift solutions there. But, come on, guys, what’s the deal? Well, once we hit that barrier, there’s only one thing to do. If I’m testing Flint, will Flint solve it? And let me give you a spoiler here. I’m going to type here,”

[12:01] hack doctor “. And we have here, look, it didn’t stop, right? Just like it stopped on the M4 Max of the person who’s opening it there. Why? Because I downloaded the project and put Flint to solve it for me. The first time I tried to install it, it gave exactly the same message, only changing the end there to M3 Ultra, which is the machine I’m running it on. So, I took Flint, which was running in LM Studio, put it together with Open Code to identify what the problem was and fix it. It

[12:32] identified it and it fixed it. And now we can run our hack here. Now I just have to type” launch open code “in the folder I want to open and it will start Flint and…It’s going to open the open window for us. Great, it’s already open here. Before we type anything, I still haven’t gotten over it. Let’s go back here quickly. I just showed this problem here, but the worst part is the response. Look, someone asked here,” Hack Doctor, it’s blocking the installation on my M4 Max. When can I expect support for the Max? “The

[13:04] response was:” Thank you for your question. “We haven’t tested it on the M4 Max yet. We’re looking into it and will update it. What? My God, it works on the M4 Pro. Okay, that’s enough. Okay, okay. Let’s go back here. Let me say hi to our model. Hi, how are you? Look, first prompt there, 10 tokens per second. Let me ask him to tell a story now. Like this, faster. 83 tokens per second. But wait, 83 tokens per second

[13:35] is less than 90. What happened? Well, what happened was a small problem called a context window. When the Okay, so here in Open Code, look, we already have 11,000 tokens in our context window. This comes from the system prompt, from the skills that are loaded , with the skill headers. Those who are students in my course know exactly what I’m talking about, but basically this is expected behavior, especially for this engine, for this model, at least for now. The community will probably tinker with this engine even further to make it even better than it is. I mean,

[14:07] if this model proves to be really good, right? In my tests, it’s already taken a first step, because it solved the M3 Ultra problem for us. So it is indeed capable of acting genetically, and it is intelligent enough to be able to identify a problem and proceed to solve it. But even here in the End documentation, we see this behavior happening, okay? This is the velocity versus context size map. So it actually starts around 125 tokens. This is in the M4 Pro. But with 8,000 tokens, it already drops below…100. See here? At

[14:40] 11,000 tokens, it would be around 90 tokens. The problem is that 90 tokens was supposed to be on the M4 Pro, I’m on the M3 Ultra, so it should be faster . For some reason, it’s not happening. And so we can see the speed a little better without the context window full, I’m going to use this tool here. Let me say hi here so we can start looking at this. Here we are. We hit 130 tokens per second. Now we’re starting to speak my language. Even so, it’s still not enough, okay? The M4 Pro hit 125. This

[15:11] one, with three times the bandwidth, should be much faster. And I think it can be. But we’ll need to modify Zendnis. Someone will do that soon. Maybe it’ll be me, maybe not. Let’s ask someone to write some code here. Create a clone of Flapbird. And then, I want to see the speed it will take here to …He decided to write everything down. He decided to do it in Python. Okay? 117 tokens per second. A total of 2,000 tokens generated. OK. That’s a good speed. But for a mixture of experts with 2 billion active parameters, less than 3 billion active parameters, I

[15:42] expected a little more. I know I’ve said this several times, I’ll stop saying it, but I expected it. Now, the next test that we need to see, let me refresh it here just to clear everything out, is the prompt processing. So, I’m going to ask him to summarize this text here in a paragraph , which is quite long, okay? Let’s see how long it takes him. Look, here’s a result. More than 100,000 tokens were processed, it took 135 seconds, also known as 2 minutes and 15 seconds. And the rate was 749 tokens per second. Here, with this level of filled context

[16:14] window, the speed dropped considerably. It went from more than 100 tokens/ second to 37. tokens/second to write this summary. This means that if you are using it programmatically within an agent, as your window size grows, the performance speed of the model will decrease quite drastically. And here we’re talking about both tokens per second and prompt processing, because if we take just half of this book here, a little less, just this excerpt here and ask it to summarize, it processed

[16:44] in 5 seconds. Let’s see how many tokens , a total of 8,000 tokens in 5 seconds. So, the rate here is already 1500 tokens per second. So, when we increase the context, the prompt processing also drops. And of course, as we were saying , token generation follows suit, right, 99 tokens per second, because the context window is small. You must be thinking, Igor, aren’t you going to make a game? Well, in this video I wanted to talk more about speed, etc. Because, well, I don’t think you will.

[17:16] It’s not suitable for making games. I want to do more tests with this model, but I think games aren’t its strong suit. It will probably perform better in tasks like piloting Leon Hermes and agentic tasks in general. This is a model that I really hope will be very good. I still need to do some more tests. Today it managed to do our presentation and it managed to adjust INne, right? But it wasn’t a very complicated adjustment, but it managed. It managed to adjust it so we could install the hack. Now, probably soon we will have MTP for this model, which is

[17:48] something we don’t have yet. So, these speeds will increase and it’s always good to have some more alternatives, right? A model with 40 billion parameters is something you don’t see every day. So, if it could take the place of the Quen with 35 billion parameters, that would be really cool, right? Hopefully, the Alibaba team will launch Quen 4 with 35 billion parameters, a mix of experts, or even a little more, a little less, because with I’m sure if you guys release it, it’s going to be amazing and it’s going to be hard for people to get there. Nobody’s reached 3.5 yet, I don’t think

[18:18] this one has either, but I want to experiment more. If you’re already experimenting with Flint, leave a comment below about the results you’re getting and what’s working for you. I want to use it more and I think it will handle some of the things I want to do. If you want to see us running some models here on the other setup with two Arc B70s, check out this link here. And also, if you want to see Flint, leave a comment down below for us. If you want to see the newest Deep Seek, we also made a video about it on the channel, just click here. Now, if you want to fully understand how AI development actually works, then make sure to click

[18:50] on this link provided right here. That way you’ll learn how to create your own skills, among many other things. But what I want to tell you is that you won’t be dependent on some magic skill or something magical to solve your problems or on a model that could double in price tomorrow. You’ll know if…It can even turn into models like Flint. I’ll leave it here, see you in the next video.