MiniMax M3.1 Flash vs. Opus 5.5: mais lento, mas 11 vezes mais barato

Autoria: Zero to MVP · 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: MiniMax M3.1 Flash vs Opus 5.5: Slower, but 11x Cheaper · Canal: Zero to MVP · 07:51 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Engenharia de software com IA, Modelos de IA, Modelos locais e open source

Resumo

O vídeo compara MiniMax M3.1 Flash e Claude Opus 5.5 em três tarefas reais de um projeto em Go: adicionar suporte a GPUs AMD, detalhar processos no dashboard e criar testes capazes de detectar bugs em um parser. Os dois modelos passaram por todas as verificações ocultas, mas Opus foi mais rápido e encontrou alguns bugs adicionais, enquanto MiniMax também identificou um bug que Opus não encontrou. Pelos preços de API, MiniMax custou US$ 0,65 no total, contra quase US$ 7 de Opus — cerca de 11 vezes menos. O autor conclui que pode delegar ao MiniMax mais da metade das tarefas, embora pretenda continuar usando Opus em alguns casos.

Pontos-chave

Os modelos realizaram as mesmas três tarefas no mesmo projeto, usando Claude Code e cópias isoladas do repo.
Na tarefa de suporte a GPUs AMD, ambos passaram pelas 18 verificações ocultas e identificaram as três armadilhas.
Na implementação do dashboard, os dois modelos passaram nos testes e escaparam corretamente o nome dos processos antes de exibi-lo na página.
Nos testes do parser, ambos detectaram os 29 bugs introduzidos nas cópias usadas para avaliação.
Opus levou 37 minutos no total, contra 61 minutos do MiniMax.
MiniMax custou US$ 0,65 no total, enquanto Opus custou quase US$ 7, aproximadamente 11 vezes mais.
Opus encontrou mais bugs reais no código, mas MiniMax também encontrou um que Opus não detectou.
O autor ressalta que são apenas três tarefas reais, não um benchmark abrangente.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação e proposta do comparativo	O autor apresenta a comparação entre MiniMax M3.1 Flash e Claude Opus 5.5 em tarefas reais de programação.
02:07	Projeto e metodologia de teste	Os modelos são avaliados no mesmo projeto em Go, com o mesmo agent, tarefas idênticas e verificações ocultas.
03:08	Tarefa 1: suporte a GPUs AMD	Os modelos implementam suporte a GPUs AMD e lidam com três armadilhas identificadas pelo autor.
04:41	Tarefa 2: processos no dashboard	A tarefa exige mostrar processos individuais no dashboard e proteger a página contra nomes maliciosos.
06:14	Tarefa 3 e conclusão	Os modelos criam testes para detectar bugs no parser, e o autor compara os resultados gerais de tempo, custo e bugs encontrados.

Citações

Na minha opinião, o principal desse modelo é o preço. — 01:35

Depois do primeiro teste, os dois modelos passaram em todas as 18 verificações ocultas e encontraram as três armadilhas. — 03:39

Os dois modelos encontraram todos os 29 bugs. — 06:14

Nos preços de API, Opus custou quase US$ 7; MiniMax, 65 centavos — 11 vezes menos. — 06:47

Decidi que agora posso delegar com segurança mais da metade das minhas tarefas ao MiniMax M3.1 Flash. — 07:18

Conceitos e entidades

MiniMax M3.1 Flash (modelo): Modelo avaliado nas três tarefas, com custo de API consideravelmente menor que o de Opus.
Claude Opus 5.5 (modelo): Modelo usado pelo autor como referência e comparado ao MiniMax em qualidade, tempo e custo.
Grid Core (repo): Projeto em Go de aproximadamente 20 mil linhas que agenda o uso de uma GPU por vários modelos locais.
Claude Code (ferramenta): agent usado para executar os dois modelos nas tarefas do projeto.
AMD (empresa): Fabricante das GPUs cuja compatibilidade foi adicionada e testada no projeto.
llama.cpp (ferramenta): Software mencionado nos testes de uso de GPUs e na visualização dos processos no dashboard.
Deep SWE (conceito): Benchmark citado como uma das avaliações em que o MiniMax obteve 73,7%.
Space Bunny (modelo): Nome misterioso que apareceu no OpenRouter e que, segundo o vídeo, foi revelado como sendo o MiniMax M3.1 Flash.

Tradução completa (pt-BR)

00:00 Há alguns dias, saiu um novo modelo, o Minimax M 3.1 Flash, e, claro, quis colocá-lo para trabalhar na mesma hora. E não em testes abstratos, mas em trabalho real. Também quis compará-lo com o Claude Opus 5.5, o modelo que mais uso atualmente. Então, dei aos dois modelos as mesmas três tarefas do meu grande projeto real em Go: duas funcionalidades novas e testes que precisam encontrar bugs. As tarefas têm armadilhas, mas o texto que os modelos receberam não dizia uma palavra sobre elas. Então, o primeiro modelo é

00:32 o Claude Opus 5.5, um dos modelos mais fortes para programação. O segundo é o novo Minimax M 3.1 Flash, que, de acordo com os testes de seus desenvolvedores, está no nível dos modelos líderes, mas custa muitas vezes menos. Vou compará-los não só pela forma como resolvem as tarefas, mas também pelo tempo e, o que é mais interessante para mim, pelo custo. Aliás, ao fim dos meus testes, o código escrito pelos modelos revelou algo que nem a ferramenta oficial de monitoramento de GPU da AMD mostra. Eu não esperava por isso.

01:04 Também quero mencionar que este vídeo é patrocinado pela Minimax. Agradeço a eles pelo acesso ao modelo, mas todas as tarefas, os testes e as conclusões são meus. Oi, sou o Nick. Trabalho com desenvolvimento de software há mais de 20 anos e, neste canal, testo ferramentas de IA em projetos reais, não em demonstrações. Primeiro, um pouco de contexto. Talvez você tenha visto recentemente um modelo misterioso chamado Space Bunny no OpenRouter. Ele ficou em primeiro lugar no OpenRouter por 10 dias seguidos e no OpenCode por 12, e ninguém sabia de quem era.

01:35 Agora, a Minimax revelou: Space Bunny é o M 3.1 Flash. Recentemente, a Minimax publicou os pesos do modelo no Hugging Face, então você pode baixá-lo e executá-lo por conta própria. Embora, com 428 bilhões de parâmetros, não dê para fazer isso em um computador comum. Na minha opinião, o principal sobre esse modelo é o preço: 15 centavos por milhão de tokens de entrada, 60 por milhão de tokens de saída, e a leitura do cache custa apenas 1 centavo e meio. Para um agente de programação, isso importa. Ele relê

02:07 o mesmo contexto a cada etapa. Nos benchmarks, o modelo é forte. Por exemplo, fez 73,7% no Deep SWE, mas quero testá-lo por conta própria, no meu projeto, com tarefas reais. Agora, algumas palavras sobre como fiz os testes. Há um mês, escrevi o Grid Core, um escalonador que compartilha uma GPU entre vários modelos locais. Tenho um vídeo separado sobre ele. Foi escrito em Go, tem cerca de 20 mil linhas de código e implementa uma lógica bastante complexa.

02:37 Foi esse o projeto que usei nos testes de hoje. Os dois modelos trabalharam no mesmo agent, o Claude Code. A Minimax se conecta a ele oficialmente por meio de uma API compatível. Então, a única coisa que mudou foi o modelo. As mesmas tarefas, o mesmo projeto. Cada modelo trabalhou em um ambiente isolado. Ele só podia ver sua própria cópia do projeto e só podia acessar sua própria API pela rede. Executei o Minimax com o raciocínio no máximo, que é a configuração padrão. Também executei o Opus no nível máximo e verifiquei as

03:08 soluções com testes ocultos que os modelos nunca viram. Então, a primeira tarefa é adicionar suporte a GPUs AMD ao projeto. No momento, o Grid Core só funciona com GPUs da Nvidia e da Apple, mas meu computador de mesa tem uma placa AMD Radeon. Portanto, esta tarefa não é só um teste: ela é realmente útil. Há três armadilhas, que descobri enquanto coletava dados da minha própria máquina. Primeiro, a máquina tem duas placas AMD, e cada processo abre as duas, mesmo que só funcione em uma.

03:39 Segundo, o llama.cpp com Vulkan abre a mesma placa duas vezes. Então, se você fizer a contagem de forma ingênua, 1,5 GB viram 3 GB. Terceiro, uma placa ociosa entra em suspensão e responde com um erro quando perguntam sobre a carga dela. No primeiro teste, os dois modelos passaram em todas as 18 verificações ocultas e encontraram por conta própria as três armadilhas. O Opus terminou em 9 minutos; o Minimax, em quase 13. Ele precisou de quase o dobro de etapas. Mas o modelo em si é muito rápido

04:10 mesmo. A alegação é de mais de 200 tokens por segundo, e eu medi 240. Aos preços da API, o Opus custou US$ 2,13. O Minimax custou 16 centavos, 13 vezes menos. Dois terços desse valor foram para reler o contexto do cache. Compilei as duas soluções e as executei na minha máquina. Um modelo usou ROCm, o outro, Vulkan. Os dois mostraram os mesmos números, que correspondiam aos dados do kernel. E a ferramenta oficial da AMD

04:41 nem sequer detecta o processo do Vulkan. Certo, vamos à segunda tarefa. No momento, o painel do Grid Core mostra os outros processos como um único bloco cinza. Quando a placa está cheia, não dá para saber o que está ocupando espaço. Outro llama.cpp, um jogo ou o desktop. Quero mostrar cada processo na placa, seu nome, sua memória e qual modelo está sendo executado nele. É isso que os modelos precisam implementar. A armadilha aqui é que o nome do processo vai direto para uma página da web, e um processo pode ter qualquer nome, inclusive

05:13 um trecho de HTML. Se o nome não for escapado, qualquer programa na máquina pode executar seu próprio código na página de administração. Verifiquei isso em um navegador de verdade, além de usar testes ocultos em Go. Os dois modelos passaram em tudo e escaparam do nome por conta própria. O Opus foi mais rápido de novo: 7 minutos e meio, contra 19. Mas o Minimax abriu sua própria página em um navegador e analisou uma captura de tela por conta própria. O custo foi de US$ 1,84 contra 23 centavos. É assim que

05:43 fica na minha máquina. Dois modelos do Grid Core e um llama.cpp. O painel mostra os três processos, e a ferramenta da AMD mostra apenas um. Certo, vamos à terceira tarefa. O Grid Core tem um analisador que lê o cabeçalho de um arquivo de modelo e determina se o modelo vai caber na memória. A tarefa é escrever testes para esse analisador que encontrem bugs sem alterar o próprio código. Não avaliei pela cobertura. Você pode executar todas as linhas e não verificar nada. Preparei

06:14 33 cópias do analisador, cada uma com um pequeno bug. Os testes existentes detectam quatro, restando 29. Os dois modelos detectaram todos os 29. Mas a parte mais interessante é que ambos encontraram bugs reais no meu código que eu desconhecia. O Opus encontrou quatro. O mais grave: um arquivo com apenas algumas dezenas de bytes faz o analisador travar para sempre. O Minimax encontrou dois, e o Opus não detectou um deles. O Opus levou 20 minutos e custou US$ 3. O Minimax levou 29 minutos e custou 26 centavos. Então, acho que é hora de fazer um balanço.

06:47 Nas três tarefas, os dois modelos passaram em todas as verificações ocultas. Aos preços da API, o Opus custou quase US$ 7, e o Minimax, 65 centavos: 11 vezes menos. Mas, em tempo, foram 37 minutos contra 61. E, na busca por bugs, o Opus foi um pouco mais a fundo. Ainda assim, o Minimax encontrou um bug que o Opus não detectou. Claro, são apenas três tarefas, não um benchmark. Mas são tarefas reais, do tipo com que lido todos os dias. Então, para mim, decidi que agora posso tranquilamente delegar mais

07:18 da metade das minhas tarefas ao Minimax M3.1 Flash, especialmente porque ele faz tudo isso por centavos. Certamente não vou abandonar completamente o Opus, mas o conjunto de tarefas em que ele é insubstituível está ficando bem menor, o que é uma boa notícia, considerando o preço alto. Você pode experimentar o modelo de hoje, o Minimax M3.1 Flash, no Minimax Code e com a assinatura do plano M. O link está na descrição. A MiniMax tem duas ofertas agora. Até 25 de outubro, quem assinar o Minimax Code terá uso ilimitado do M3.1 Flash, e o plano M está com 50% de desconto no primeiro mês para novas assinaturas e upgrades até 31 de outubro.

07:51 Se você se interessa por testes de modelos de IA no mundo real como este, inscreva-se no canal e na minha newsletter semanal. O link está na descrição. Até breve. Fiquem bem.

Transcrição original

[00:00] A few days ago, a new model came out, Minimax M 3.1 Flash, and of course I wanted to put it to work right away. And not on abstract tests, but in real work. I also wanted to compare it with Claude Opus 5.5, the model I mostly use right now. So, I gave both models the same three tasks from my real large Go project, two new features and tests that have to find bugs. The tasks have traps, but the text the models got didn’t say a word about them. So, the first model is

[00:32] Claude Opus 5.5, one of the strongest models for code. The second is the new Minimax M 3.1 Flash, which according to its developers’ tests is on the level of leading models, but costs many times less. I’ll compare them not only on how they solve the tasks, but also on time and most interesting for me, on cost. By the way, by the end of my tests, the code the models wrote showed something that even AMD’s official GPU monitoring tool doesn’t show. I didn’t expect that.

[01:04] I also want to mention that this video is sponsored by Minimax. Thanks to them for access to the model, but all the tasks, tests, and conclusions are my own. Hi, I’m Nick. I’ve been building software for over 20 years, and on this channel I test AI tools on real projects, not demos. First, a bit of backstory. You may have recently seen a mysterious model called Space Bunny on Open Router. It was number one on Open Router for 10 days in a row, and on Open Code for 12, and nobody knew whose it

[01:35] was. Now, Minimax has revealed it. Space Bunny is M 3.1 Flash, and recently Minimax published the model’s weights on Hugging Face, so you can download it and run it yourself. Although with 428 billion parameters, not on a regular computer. In my opinion, the main thing about this model is the price, 15 cents per million input tokens, 60 per million output tokens, and reading from the cache is just 1 and 1/2 cents. For a coding agent, this matters. It rereads

[02:07] the same context at every step. On benchmarks, the model is strong. For example, 73.7% on Deep SWE, but I want to test it myself on my own project with real tasks. Now, a few words about how I tested. A month ago, I wrote Grid Core, a scheduler that shares one GPU between several local models. I have a separate video about it. It’s written in Go, has about 20,000 lines of code, and implements some fairly complex logic.

[02:37] That is the project I used for today’s tests. Both models worked in the same agent, Claude Code. Minimax officially connects to it through a compatible API. So, the only thing that changed was the model. Same tasks, same project. Each model worked in a sandbox. It could see only its own copy of the project, and could reach only its own API over the network. Minimax run at max reasoning, its default. I also run Opus at the maximum level, and I checked the

[03:08] solutions with hidden tests the models never saw. So, the first task is adding AMD GPU support to the project. Right now, Grid Core only works with Nvidia and Apple GPU, but my desktop has an AMD Radeon card. So, this task isn’t just a test, it’s actually useful. It has three traps, and I found them while collecting data from my own machine. First, the machine has two AMD cards, and every process opens both, even if it only runs

[03:39] on one. Second, llama.cpp on Vulkan opens the same card twice. So, if you count naively, 1 and 1/2 GB turn into three. Third, an idle card goes to sleep and answers a question about its load with an error. After the first test, both models passed all 18 hidden checks and found all three traps on their own. Opus finished in 9 minutes, Minimax in almost 13. It took almost twice as many steps. The model itself is very fast

[04:10] though. Over 200 tokens per second is the claim and I measured 240. At API prices, Opus cost $2 and 13 cents. Minimax cost 16 cents, 13 times cheaper. 2/3 of that went to rereading the context from the cache. I built both solutions and run them on my machine. One model on ROCm, the other on Vulcan. Both showed the same numbers and they matched the kernel’s data. And AMD’s

[04:41] official tool doesn’t see the Vulcan process at all. Okay, on to the second task. Right now, the grid core dashboard shows other processes as one gray block. When the card is full, you can’t tell what’s in there. Another llama.cpp, a game, or the desktop. I want to show every process on the card, its name, its memory, and which model runs in it. That’s what the models have to build. The trap here is that the process name goes straight into a web page and a process can be named anything, including

[05:13] a piece of HTML. If the name isn’t escaped, any program on the machine can run its own code in the admin page. I checked this in a real browser, plus hidden tests in go. Both models passed everything and both escaped the name on their own. Opus was faster again, 7 and 1/2 minutes against 19. But Minimax opened its own page in a browser and looked at a screenshot itself. Cost, $1.84 against 23 cents. Here’s what it

[05:43] looks like on my machine. Two grid core models and a llama.cpp. The dashboard shows all three processes and AMD’s tool shows only one. All right, on to the third task. Grid core has a parser that reads the header of a model file and works out whether a model will fit in memory. The task is to write tests for this parser that catch bugs without changing the code itself. I didn’t judge by coverage. You can run every line and check nothing. I prepared

[06:14] 33 copies of the parser, each with one small bug. The existing tests catch four, which leaves 29. Both models caught all 29, but the more interesting part, both found real bugs in my code that I didn’t know about. Opus found four. The nastiest one, a file a few dozen bytes long, hangs the parser for good. Minimax found two and Opus missed one of them. Opus took 20 minutes and $3. Minimax took 29 minutes and 26 cents. So, I think it’s time to sum up.

[06:47] Across the three tasks, both models passed every hidden check. At API prices, Opus cost almost $7, Minimax 65 cents, 11 times cheaper. But in time, it was 37 minutes against 61. And in finding the bugs, Opus dug a little deeper. Still, Minimax found a bug that Opus missed. Of course, this is just three tasks, not a benchmark. But these are real tasks, the kind I deal with every day. So, for myself, I’ve decided that I can now safely hand over more

[07:18] than half of my tasks to Minimax M3.1 Flash, especially since it does all of it for cents. I’m certainly not giving up Opus completely, but the range of tasks where it’s irreplaceable is getting much narrower, which is good news given how expensive it is. You can try today’s model, Minimax M3.1 Flash, in Minimax code and with the M plan subscription. The link is in the description. Mini Mox has two offers right now. Until October 25th, Mini Mox code subscribers get M3.1 flash with no

[07:51] limits, and the M plan is 50% off the first month for new subscribers and upgrades until October 31st. If you’re interested in real-world tests of AI models like this, subscribe to the channel and to my weekly newsletter. The link is in the description. See you soon. Take care.