Flint v1.0 vs North Mini Code: dois MoEs abertos de codificação disputando seu laptop

A maioria das páginas de "versus" deste site compara coisas que nunca foram realmente rivais. Esta é diferente. Recursive Flint v1.0 e Cohere North Mini Code são o mesmo tipo de objeto: modelos de código de mistura esparsa de especialistas, publicados sob Apache 2.0, pequenos o suficiente para rodar em hardware que um desenvolvedor já possui, e ambos posicionados como a opção local em vez da de fronteira. Flint chegou em 21 de outubro de 2026 com 39,8 bilhões de parâmetros totais e cerca de 2,5 bilhões ativos por token. North Mini Code chegou em 9 de junho de 2026 com 30 bilhões totais e 3 bilhões ativos. Isso é próximo o bastante para que a escolha se resuma ao que está no arquivo e ao que foi realmente medido — e, nos dois aspectos, a resposta não é a que a cobertura de lançamento sugere.

Os dois arquivos, dimensão por dimensão

Comece pelo que vem na caixa, porque, para dois modelos auto-hospedados, essa é a comparação que resiste ao contato com a realidade.

• Total de parâmetros — Flint: 39,8B. North Mini Code: 30B.

• Parâmetros ativos por token — Flint: cerca de 2,5B, com 2,2B no corpo e o restante na cabeça de saída. North Mini Code: 3B. Praticamente idêntico, e este é o número que rege o custo de inferência.

• Roteamento de especialistas — Flint: 256 especialistas roteados, 6 selecionados por token, mais 1 compartilhado, em 47 camadas MoE e 2 camadas densas. North Mini Code: 128 especialistas, 8 ativos por token.

• Atenção — Flint: uma mistura de camadas de janela deslizante e globais com sumidouros de atenção. North Mini Code: uma proporção de 3:1 entre janela deslizante e globais. Ambos estão fazendo a mesma aposta: que a maioria dos tokens só precisa de atenção local e alguns precisam da janela inteira.

• Contexto — Flint: 262.144 tokens documentados na ficha do modelo, com o anúncio mencionando até 512K e recomendando 256K. North Mini Code: 256K de entrada, 64K de saída máxima.

• Modalidade — Flint: texto entra, texto sai. North Mini Code: texto entra, texto sai. Nenhum dos dois aceita imagens, o que importa se o seu trabalho envolve capturas de tela.

• Licença — ambos Apache 2.0, pesos incluídos, sem restrição de receita.

• Formatos publicados — Flint: BF16, int4 safetensors, int4 GGUF, NVFP4 GGUF. North Mini Code: BF16, FP8 e W4A16.

• Disco e memória — Flint: 79,59 GB em BF16, 22,86 GB como NVFP4 e cerca de 24 GB de memória para executar. North Mini Code: cerca de 20 a 24 GB quantizados, com a própria demonstração da Cohere rodando em um Mac Studio com cerca de 20 GB.

A memória é o primeiro corte, e está mais próxima do que as contagens de parâmetros sugerem

A leitura ingênua de 39,8B versus 30B é que o Flint precisa de um terço a mais de memória. Não precisa, porque ambos são esparsos e ambos publicam builds quantizados agressivos. O que você está realmente escolhendo é entre um arquivo NVFP4 de 22,86 GB e um build quantizado de aproximadamente 20 GB — próximos o suficiente para que a mesma placa de 24 GB execute qualquer um dos dois, e próximos o suficiente para que nenhum seja a escolha óbvia apenas pela pegada.

O que difere é a margem de folga. O North Mini Code foi relatado rodando um GGUF de 4 bits em um Ryzen 7 com 32 GB de DDR4 — um desktop genuinamente comum, não uma workstation. A afirmação de Flint sobre laptop é mais específica: os números de throughput da Recursive são medidos em um MacBook Pro M4 Pro e em um RTX Spark de 64 GB, ambos máquinas premium. O arquivo de 22,86 GB vai carregar em uma placa de 24 GB. Se ele roda a uma velocidade que você toleraria é uma questão separada, e depende muito da engine.

Se a sua restrição é "a máquina que eu já tenho", o North Mini Code tem mais relatos de funcionar em hardware comum. Se a sua restrição é "a melhor máquina que eu tenho", o Flint é a arquitetura mais nova e o mais rápido em contexto curto.

Um deles tem um placar independente.

Esta é a parte da comparação que a maioria das análises ignora, e é a parte que deveria decidir uma aquisição.

O North Mini Code foi avaliado pela Artificial Analysis. Ele obtém 33,4 no AA Coding Index e 27,6 no AA Intelligence Index, com SWE-bench Verified em 67,6 pass@1 e 80,2 pass@10, e 61,0 no mini-SWE-Agent. Essas são medições de terceiros produzidas em um protocolo consistente, o que significa que podem ser comparadas com outros modelos no mesmo índice sem uma nota de rodapé sobre os harnesses.

Flint não tem registro no Artificial Analysis. Suas pontuações publicadas — 74,2 no SWE-bench Verified, 89,7 no SWE-bench Pro v2, 54,9 no Terminal-Bench 2.1 — vêm do próprio harness da Recursive, e ninguém as reexecutou. A metodologia é divulgada, o que é mérito da Recursive: mini-swe-agent sem internet para as execuções do SWE-bench, Terminus 2 com internet para o Terminal-Bench, mas qualquer solução obtida na web contada como falha, pass@1 calculado em média sobre pelo menos cinco tentativas. Metodologia divulgada não é metodologia verificada.

Então você pode comparar 67,6 com 74,2? Não de forma responsável. Eles foram produzidos por organizações diferentes, em harnesses diferentes e com regras diferentes, e a diferença — 6,6 pontos — está bem dentro da faixa que a escolha do harness sozinha pode deslocar uma pontuação. O que você pode dizer é mais restrito e ainda assim útil: o número do North Mini Code foi verificado por alguém que não construiu o modelo, e o do Flint não foi. Se você está escolhendo com base em evidências e não em especificações, é essa a assimetria que importa.

Há mais um dado na coluna do North Mini Code que é pouco lisonjeiro e vale a pena ter: o Artificial Analysis sinalizou-o como incomumente prolixo, consumindo cerca de 75 milhões de tokens de saída nos testes, contra uma mediana da categoria perto de 25 milhões. A verbosidade é um multiplicador de custo em um loop de agente. Um modelo que pensa em voz alta três vezes mais pode ser mais barato por token e mais caro por tarefa.

A questão da velocidade muda completamente em contextos longos.

Ambos os modelos são rápidos com prompts curtos, e ambos desaceleram quando o contexto enche. A diferença é o quanto.

• Flint — Recursive afirma mais de 125 tokens por segundo em um MacBook Pro M4 Pro e mais de 150 em um RTX Spark de 64 GB, medidos em contexto curto com o prefill excluído. Testes independentes relataram cerca de 110 tokens por segundo com prompts curtos, caindo para aproximadamente 9 tokens por segundo perto de 115.000 tokens de contexto. Esse é o número com base no qual você deve projetar seu agente, porque a codificação agêntica passa a maior parte da sua vida no regime de contexto longo.

• North Mini Code — cerca de 199 a 210 tokens de saída por segundo na API da Cohere, com aproximadamente 0,25 segundos até o primeiro token, e cerca de 2,8 vezes a vazão de modelos pequenos comparáveis no mesmo teste. Em hardware local, os números dependem inteiramente do seu mecanismo e da quantização, mas o padrão é o mesmo: rápido em contexto curto, mais lento à medida que a janela enche.

A comparação honesta não é "qual é mais rápido", mas "qual é mais rápido para o modo como um agente realmente funciona". Um modelo que escreve um token em 8 milissegundos com contexto de 4K e 110 milissegundos com 115K é um produto diferente de um que degrada mais suavemente. Nenhum dos fornecedores publica uma curva. Se o trabalho agêntico com contexto longo é o seu caso de uso, meça no seu próprio repositório antes de se comprometer — é trabalho de uma tarde e lhe dirá mais do que qualquer uma das postagens de lançamento.

Impulso versus frescor

O North Mini Code ultrapassou 150.000 downloads em meados de agosto de 2026, dois meses após o lançamento. Isso é um sinal real: um modelo com esse nível de adoção foi executado em hardware que seus autores nunca testaram, acumulou correções na comunidade e teve suas arestas documentadas por pessoas sem qualquer incentivo para serem gentis. A Cohere informou o número, então considere-o como informado pelo fornecedor, mas a tendência é corroborada pelo volume de quantizações derivadas em circulação.

Flint tem quatro dias de vida. Ele tem melhores especificações de destaque, uma decodificação de contexto curto mais rápida, uma janela de contexto documentada mais longa e uma história de desenvolvimento mais interessante. Ele também tem um bug conhecido de template de chat no caminho GGUF para llama.cpp, uma queda abrupta de throughput em contexto longo que ninguém explicou e essencialmente nenhum histórico de comunidade. A adoção precoce de um modelo de quatro dias de vida é uma aposta na trajetória, e não uma avaliação do artefato.

O que baixar na segunda-feira

• Escolha o North Mini Code se você quiser o modelo com uma pontuação independente associada, se seu hardware for modesto, se suas tarefas forem engenharia de software comum em um repositório que caiba confortavelmente no contexto, e se você valorizar dois meses de relatos de bugs da comunidade em vez de uma arquitetura mais recente. Reserve margem para a verbosidade dele.

• Escolha o Flint se você tiver um laptop premium ou uma placa de 24 GB, se quiser a janela de contexto mais longa, se a velocidade em contexto curto for o que seu fluxo de trabalho realmente exercita e se estiver disposto a ser um early adopter em troca de um modelo que, plausivelmente, será o melhor daqui a um mês.

• Não escolha nenhum dos dois como sua única opção. Ambos são modelos com 2,5 a 3B de parâmetros ativos. São excelentes em tarefas de escopo definido e não são assistentes de programação de ponta, e a Recursive diz exatamente isso sobre seu próprio modelo. O trabalho que nenhum dos dois fará bem é o trabalho que exige um modelo de ponta hospedado — e a arquitetura sensata é um padrão local com um caminho de escalonamento, não um único modelo ao qual se pede que seja tudo.

Esse caminho de escalonamento é onde o roteamento se justifica. O OrcaRouter não atende nenhum desses modelos, então nada aqui é uma propaganda de uma rota para eles. O que uma camada de roteamento faz por uma configuração local-first é na outra direção: permite compor as tarefas que precisam de um modelo hospedado maior no mesmo caminho de chamada, com uma cadeia de fallback para as requisições em que o modelo local trava ou o contexto transborda. Bem configurado, o modelo local cuida do trabalho rotineiro e o modelo caro só é acionado quando realmente necessário — que é a única versão dessa arquitetura que economiza dinheiro.

A resposta entediante é a correta. Ambos os arquivos são gratuitos, ambos rodam em hardware que você provavelmente tem, e a única forma de saber qual deles se adequa ao seu repositório é testar os dois nele. A diferença de benchmark entre eles é menor do que a diferença entre qualquer um deles e a sua carga de trabalho real.