Modelos de linguagem por difusão escalam? Testando Mercury 3 e Mercury Decide

Ver no idioma original →

Autoria: Sam Witteveen · 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: Do Diffusion LLMs Scale? Testing Mercury 3 + Decide · Canal: Sam Witteveen · 21:28 · 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 multimodais

Resumo

O vídeo apresenta Mercury 3 e Mercury Decide, modelos de Inception que usam difusão para gerar texto e tomar decisões com baixa latência. O apresentador explica como a geração por difusão difere da geração autorregressiva e revisa benchmarks, velocidade, preços e aplicações. Em demonstrações, Mercury 3 é testado em geração de textos longos, tool calling, RAG e tarefas de agente, enquanto Mercury Decide é usado para classificar tickets e analisar imagens. O vídeo conclui que os dois modelos podem ser combinados em um fluxo de triagem, resposta e verificação, e que os resultados sugerem que modelos de linguagem por difusão podem escalar.

Pontos-chave

• Mercury 3 gera mais de mil tokens por segundo, segundo os números apresentados no vídeo.
• Modelos por difusão refinam vários tokens em paralelo, em vez de gerar a resposta token por token.
• O apresentador relata bons resultados de Mercury 3 em tool calling, RAG e produção de textos longos.
• Mercury Decide responde a perguntas de classificação com probabilidades e também aceita imagens.
• O vídeo destaca o uso de scores de confiança para encaminhar casos incertos a uma pessoa.
• Mercury 3 é apresentado como adequado a tarefas em que a latência se acumula, como agentes e busca por voz.
• Mercury Decide é sugerido para verificações de alto volume, moderação e roteamento.
• Os dois modelos podem ser combinados: Mercury Decide faz a triagem e as verificações, e Mercury 3 redige a resposta.

Capítulos

Início	Capítulo	Resumo
00:00	A promessa de velocidade dos modelos por difusão	O apresentador introduz Mercury 3 e Mercury Decide e pergunta se modelos de linguagem por difusão conseguem escalar.
01:35	Como funciona a geração por difusão	O vídeo compara a geração autorregressiva, token por token, ao refinamento paralelo de várias partes do texto.
03:17	Escala, benchmarks e velocidade de Mercury 3	O apresentador revisa o crescimento dos modelos de Inception, compara benchmarks e destaca a velocidade, os preços e os casos de uso de Mercury 3.
07:31	Mercury Decide e os modelos de decisão	O vídeo explica o papel de Mercury Decide e apresenta resultados de evals, latência e análise de imagens.
09:40	Demonstração de Mercury 3 e Mercury Decide	O apresentador mostra geração de texto, tool calling, RAG, classificação de tickets e decisões com base em imagens.
19:12	Combinando os modelos e principais aplicações	Uma demonstração combina triagem com Mercury Decide e redação com Mercury 3, seguida de sugestões de uso e da conclusão sobre escala.

Citações

Você não precisa mais abrir mão de toda a inteligência só para ter velocidade. — 00:31

Eles refinam muitos tokens em paralelo ao longo de algumas etapas. — 02:07

Esses modelos não geram texto algum. — 08:03

A difusão parece escalar para modelos de linguagem. — 21:28

Conceitos e entidades

• diffusion language models (conceito): Modelos de linguagem que refinam partes da resposta em paralelo ao longo de várias etapas.
• autoregressive models (conceito): Modelos que geram texto prevendo um token de cada vez, em sequência.
• decision model (conceito): Modelo que recebe um estado e perguntas e retorna decisões, normalmente acompanhadas de probabilidades ou scores de confiança.
• Mercury 3 (modelo): Modelo de linguagem por difusão de Inception apresentado para geração rápida, raciocínio e tarefas de agente.
• Mercury Decide (modelo): Modelo de decisão por difusão de Inception que processa texto e imagens e retorna respostas com probabilidades.
• Inception (empresa): Empresa que desenvolveu Mercury 3 e Mercury Decide.
• Jev (modelo): Modelo de decisão usado como referência de comparação para Mercury Decide no vídeo.
• OpenRouter (ferramenta): Plataforma mencionada como uma das opções para experimentar os modelos.
• Sam Witteveen (pessoa): Apresentador do vídeo, que demonstra e avalia os modelos.

Tradução completa (pt-BR)

00:00 Certo, a maioria dos grandes laboratórios de IA está correndo em uma direção: está totalmente focada em inteligência. Cada novo lançamento busca superar algum outro benchmark. E, na verdade, quando se trata de velocidade, essa não é a principal preocupação deles. Por muito tempo, essa foi basicamente a história dos modelos autoregressivos, certo? Você prevê um token de cada vez. Bem, os modelos de linguagem de difusão foram a exceção. Eles sempre foram muito mais rápidos do que os LLMs normais. Mas, por muito tempo, vieram com uma desvantagem.

00:31 Eles simplesmente não tinham um desempenho tão bom. Dá para pensar neles como modelos pequenos e rápidos que você poderia usar para completar texto, mas não como modelos aos quais confiaria uma tarefa real de agent. Bem, preciso dizer que, com Mercury 3 e Mercury Decide, isso mudou completamente. O próprio Mercury 3 roda a mais de 1.000 tokens por segundo. E, nos benchmarks da Inception, fica na mesma faixa que GPT-6 Luna e Claude Haiku 5.5. Então, você não precisa mais abrir mão de toda a inteligência só para ter velocidade, e Mercury 3 não é a única coisa em que eles vêm trabalhando.

01:04 Além disso, há Mercury Decide, a versão deles de um decision model no estilo de Jev, e, enquanto estou gravando isto, ele está disponível de graça no OpenRouter. Quando a Inception entrou em contato para me dar acesso antecipado a esse modelo e patrocinar o vídeo, fiquei muito curioso para ver até onde os modelos de difusão realmente chegaram para LLMs. Então, neste vídeo, vou analisar os dois modelos. Vamos ver benchmarks, alguns da Inception, mas também alguns de terceiros, e vou mostrar testes que fiz por conta própria e descobrir onde

01:35 os modelos de linguagem de difusão estão hoje. Certo, se você não sabe nada sobre LLMs de difusão, deixe-me explicar um pouco sobre eles. Então, em que eles são realmente diferentes? Bem, a maioria dos LLMs é autoregressiva. Dá para pensar neles como se escrevessem em uma máquina de escrever: um token, depois o próximo, depois o seguinte, e cada token exige uma passagem completa pelo modelo. Por isso a velocidade de decodificação é tão importante. A difusão, por outro lado, funciona muito mais como um editor. Ela começa com um rascunho inicial de toda a resposta, com partes mascaradas, e

02:07 depois refina muitos tokens em paralelo ao longo de algumas passagens, então cada passagem realiza mais trabalho útil. E, como a inference é limitada principalmente pela largura de banda da memória, não pela capacidade de processamento, a aceleração vem de obter muitos tokens em cada passagem. E, se a ideia de difusão parece familiar, deveria mesmo, certo? É a mesma ideia básica por trás da maioria dos geradores de imagens e vídeos que existem hoje. Preciso destacar que não é coincidência que o CEO da Inception, Stefano Ermon, seja um dos coinventores de alguns dos principais

02:42 métodos de difusão por trás da geração moderna de imagens e vídeos. A equipe fundadora da Inception trabalha há bastante tempo em técnicas como essas, além de muitas outras que usamos, como DPO, flash attention etc. Então, essa equipe claramente é formada por pessoas que entenderam a difusão desde cedo, e elas vêm trabalhando duro há algum tempo para provar que isso pode funcionar tão bem para texto quanto para imagens. E a grande pergunta sobre os LLMs de difusão sempre foi: eles escalam? Na ICML de 2024, participei do círculo de difusão de Sander Dieleman

03:17 e perguntei especificamente a ele sobre isso na época. Parecia que a difusão assumiria o lugar dos LLMs, assim como aconteceu com a geração de imagens, a geração de vídeos e até coisas como a geração de música? Naquela época, essa era realmente uma questão em aberto. Ninguém tinha conseguido mostrar que esses modelos podiam escalar até tamanhos em que se tornassem modelos de linguagem muito fortes. Agora, a Inception é quem mostrou que isso pode escalar. E é bem legal que uma startup relativamente pequena esteja fazendo isso. No começo, eles começaram com Mercury 1.

03:49 Eles mostraram como era possível criar um modelo de difusão comercial e, se você olhar este gráfico, ele mostra o que aconteceu desde então. De Mercury 1 Mini a Mercury 3, eles aumentaram o total de parâmetros em mais de 40 vezes, e a média de inteligência subiu 3 vezes. O que acho interessante é que o salto de Mercury 2 para 2.5 aconteceu com modelos de tamanho aproximadamente igual. Então, parece que esse ganho veio do treinamento, não da escala. Mas, de 2.5 para 3, eles realmente aumentaram bastante o tamanho do modelo.

04:20 Então, as duas alavancas parecem estar funcionando para a difusão, exatamente o que queremos ver para que ela decole. Não se esqueça de que estamos falando de uma startup que não tem nem de longe os recursos de grandes empresas como OpenAI e Anthropic etc. Certo, então como Mercury 3 se compara a modelos da mesma categoria? Aqui, a comparação é basicamente com GPT-6 Luna e Claude Haiku 5.5. Ele é forte em raciocínio, cumprimento de instruções e busca. Está indo muito bem no GPQA Diamond. Na verdade, dá para ver que ele está

04:51 indo bem em muitos desses benchmarks, incluindo os benchmarks de busca agentic. Embora não esteja no nível de Opus 5.5 para programação agentic, ainda é adequado para tarefas de nível médio e como modelo padrão para subagents de programação. E a ideia de ter, basicamente, enxames de agents combina muito bem com esse modelo. Quando se tem algo tão rápido assim, dá para usá-lo em várias ideias diferentes, como ciclos recursivos de autoaperfeiçoamento e compreensão de grandes bases de código,

05:22 e em qualquer situação em que você tenha uma quantidade muito grande de dados que queira que vários subagents analisem e interpretem. Se estiver criando algo como um agent de busca ou um bot de suporte, em que seguir instruções é muito importante e a velocidade também, Mercury 3 parece muito forte. Isso foi só a comparação dos benchmarks de inteligência. Se começarmos a analisar a velocidade, os números da Inception realmente disparam. Mercury 3 consegue chegar a 1.068 tokens por segundo na NVIDIA Blackwell. Se você comparar

05:52 isso com os outros modelos, é cerca de oito vezes mais do que Luna consegue, e até 4,5 vezes mais do que Claude Haiku. E, como você vai ver na demonstração que vou mostrar, essa coisa dispara na hora de gerar texto. Você também pode aumentar ou diminuir o esforço de raciocínio, e vai ver como isso pode fazer as respostas chegarem rapidamente. Certo, então em que situações isso realmente importa? A Inception tem alguns clientes iniciais compartilhando números. O que mais gostei foi o da OcTen, que faz buscas em óculos inteligentes. A busca levava cerca de 80 milissegundos,

06:26 então o modelo era o gargalo. Com Mercury 3, o tempo de geração é de 0,9 segundo. E dá para imaginar que, com óculos inteligentes, qualquer coisa que leve alguns segundos de repente vai fazer as pessoas pensarem que algo está quebrado. O preço no lançamento será de 10 centavos por milhão de tokens de entrada e 35 centavos por milhão de tokens de saída, o que representa, na verdade, 50% de desconto. Vai ser interessante ver por quanto tempo eles vão manter esse preço. Então, no longo prazo, talvez fique um pouco mais caro do que Luna ou Haiku, mas você ainda tem vantagens como entradas em cache com 90% de desconto.

06:58 E, se o seu agent reenviar o mesmo contexto a cada etapa, isso vai se acumular bastante. Então, a ideia é que você está pagando pela velocidade, não economizando em tokens. Outro exemplo que mencionaram foi a Tinyfish, que cria agents para a web. Na publicação do blog, eles falam de outros exemplos de pessoas que conseguem fazer muito mais simplesmente porque o modelo é muito mais rápido. E o legal é que ele é totalmente compatível com OpenAI, então, para trocar, basicamente basta mudar a URL base. Ele oferece suporte a tool calling e a saídas estruturadas, e também oferece suporte a

07:31 uma context window de um milhão de tokens, acima dos 260 mil do modelo anterior. E também é ótimo ver que eles facilitaram bastante para as pessoas experimentarem. Ele está disponível não apenas na própria API, mas também no OpenRouter, Base10 e Vercel. Certo, então Mercury 3 é o modelo de raciocínio. É o lado do sistema dois. Mas, como venho falando no canal há bastante tempo, muitas coisas exigem um tipo de decisão de sistema um realmente rápido. É exatamente esse tipo de coisa: agents que precisam fazer chamadas muito rápidas.

08:03 Isto é um chamado de cobrança? Um agent está travado? Uma página realmente carregou? Já falei bastante sobre isso no canal: é para isso que servem os decision models. Esses modelos não geram texto algum. Você fornece um estado e uma pergunta, e eles retornam uma resposta e uma probabilidade em uma única chamada. Então, é aqui que o Mercury Decide se encaixa: é um decision model de difusão. Você passa um estado, e o legal é que ele pode ser texto, mas também pode ser imagens. Você passa um conjunto de perguntas tipadas, e então o modelo processa tudo isso e retorna sua resposta em uma

08:36 fração de segundo. Então, qual é o desempenho dele? Em vez de simplesmente acreditar na palavra da Inception, vamos analisar alguns dos evals independentes deste modelo. A Val’s AI o submeteu ao mesmo teste que usou com Jev para verificação de reivindicações, e ele já estava no mesmo nível que Jev. No LegalBench, o Mercury Decide está claramente à frente, com pontuação em torno de 87%, contra 74%. E aqui vem a parte legal: ele custa cerca de um quarto do preço do Jev, e há uma versão gratuita que você também pode experimentar no OpenRouter. No artificial analysis decision index, este modelo está em terceiro lugar

09:10 em não alucinar, com 32%. E, como comentei nos outros vídeos sobre decision models, isso realmente importa quando você quer um modelo que diga que não tem certeza, em vez de simplesmente chutar. Quanto à velocidade, a Valls mediu uma mediana de cerca de 0,16 segundo para um único julgamento e de 0,4 segundo para 64 julgamentos. Então, um caso de uso claramente excelente para isso é quando você fornece um contexto e faz várias perguntas sobre ele ao mesmo tempo. Agora, a novidade na versão mais recente

09:40 do Mercury Decide é a visão, e realmente acho que esse é um padrão que muitos outros agents vão adotar. Verificações baratas de System 1 em torno de uma única chamada de System 2. Você reserva o raciocínio caro para as partes que precisam dele e obtém uma pontuação de confiança em cada etapa, que pode usar para encaminhar o caso a uma pessoa, se necessário. Certo, vamos à demonstração. Preparei um pequeno aplicativo para testar isso. Vou mostrar várias coisas diferentes aqui que acho muito legais nesta suíte de testes e na minha suíte de testes habitual. Primeiro, se você nunca usou um LLM de difusão, provavelmente

10:13 vai ficar meio chocado, primeiro, com a rapidez dele e, segundo, com a forma como ele produz os tokens. Vamos ver. Vou pedir que explique como os modelos de linguagem de difusão diferem dos autorregressivos. Você vai ver que demora um pouco para começar. Tenho algumas configurações aqui. Mas dá para ver como ele avança muito rápido e, conforme isso acontece, você também vai notar que ele já terminou. Certo. O que podemos fazer aqui é usar um recurso que adicionei para reproduzir isso e deixar mais lento. Se eu vier aqui e reproduzir, dá para ver que voltei uma etapa,

10:47 assim podemos ver o que aconteceu em cada quadro, conforme avançamos. E dá para ver que ele vai ajustando as coisas aos poucos, à medida que prossegue. Ele determina os diferentes tokens, como, por exemplo, como os tokens devem se combinar, e isso é bem diferente de um LLM padrão, certo? Na verdade, posso percorrer isso manualmente, para desacelerar e observar. Certo? Com um LLM autorregressivo normal, depois que ele se compromete com um token, ele

11:17 não consegue realmente voltar e alterá-lo. Já houve alguns artigos que tentaram diferentes maneiras de retroceder e coisas do tipo, mas, fundamentalmente, ele funciona etapa por etapa. Aqui, dá para ver que ele começa a esboçar alguns parágrafos diferentes e depois passa a refiná-los. Então, dá para ver que, à medida que avança, ele decide o que deve ficar naquele começo. E, quando voltamos aqui, ele tinha colocado isso ali, mas ainda está…

11:47 e tem “auto alguma coisa SemIf”. Mas, conforme avançamos pelos quadros, ele começa basicamente a juntar tudo. E, de fato, acaba montando parágrafos inteiros e, por fim, chega ao final, onde reuniu toda a resposta. E dá para ver que a resposta está perfeitamente legível, certo? Não há nada de estranho no texto produzido pelo LLM de difusão. O que é fundamentalmente diferente é apenas a maneira como ele o produz.

12:20 Então, uma das primeiras coisas realmente legais de ver aqui é a velocidade com que isso acontece. Dá para ver: foi muito rápido. Vou executar de novo para você ver. Não estou acelerando nada aqui. Estou mostrando a velocidade real, certo? Leva um tempinho para os primeiros tokens aparecerem, embora seja tão rápido que nem dá tempo de eu dizer isso. Mas, fundamentalmente, ele monta tudo e termina muito rápido. Essa é a vantagem da difusão, certo?

12:51 E você vai ver que, se eu der a ele um dos meus prompts habituais para escrever um ensaio de 5.000 palavras, ainda vai levar um tempinho. São 5.000 palavras, e dá para ver que o tempo até o primeiro token está demorando um pouco para começar. Mas, à medida que avança, ele basicamente reúne tudo isso e gera o resultado. E, se eu acelerar aqui embaixo, dá para ver que ele ainda está montando o final do documento. Então, ele avança em blocos, juntando tudo. Mas este modelo é muito bom em conseguir montar o texto inteiro.

13:23 Até agora, nos meus testes, não vejo que ele faça o que muitos modelos open source fazem: escrever apenas metade do ensaio ou responder algo como: “Ah, se eu fosse continuar, chegaria a isto, isto e isto”. Então, esse é um dos aspectos interessantes. E dá para ver que, se eu vier aqui e colar o resultado, são 4.200 palavras, o que certamente é bem melhor do que o que muitos modelos estão produzindo. Certo. Se formos para o meu ambiente habitual de testes, podemos experimentá-lo

13:54 também em coisas como os testes padrão de tool calling agêntico. E dá para ver que ele está passando por tudo tão rápido que, embora haja 10 testes aqui e um modelo autorregressivo muitas vezes levasse bastante tempo para fazer isso, eu normalmente até pausaria. Não estou conseguindo pausá-lo aqui. Ele passou por tudo, acertou 10 de 10 e se saiu muito bem. Não teve aquele excesso de raciocínio que vemos em alguns deles. Se eu descer e der a ele os testes mais avançados, de novo, a velocidade das

14:26 respostas é muito boa aqui. Então, ele está se saindo muito bem, e essa é uma das coisas com que até alguns dos modelos da Meta tiveram problemas, em alguns desses casos. Mas vou deixar isso rodar. Ele passou por tudo e basicamente acertou os oito, perfeitamente, certo? Então, essa é uma das coisas legais deste modelo: ele consegue fazer todos esses tipos de tarefa. E, para coisas como RAG, faz um ótimo trabalho. Dá para ver que ele processou 4.000 tokens muito rapidamente, passando

14:56 por ali para basicamente encontrar as respostas certas. Ele estava processando a entrada para extrair as informações. Então, esse é o Mercury 3, que é o modelo de System 2 deles, certo? É basicamente onde está toda a inteligência, onde ele faz bastante raciocínio, esse tipo de coisa. Se mudarmos para o Mercury Decide, agora temos o modelo de System 1. E é basicamente aqui que temos todos aqueles decision models no estilo do Jev em ação. Então, podemos passar um chamado de suporte por ele. E você vai ver

15:29 O mais impressionante aqui é que, literalmente, quase só preciso apertar o botão, e ele já me dá a resposta de volta, muito rápido. Então, basicamente, vou deixar rodando, e vocês podem ver: pronto, terminou. Basicamente, já fez as classificações deste teste. Temos os casos normais, as escolhas e uma pontuação aqui. E o modelo se saiu muito bem. Também podemos ver os níveis de confiança de coisas como a escolha e a pontuação. Se quisermos ver exatamente o que foi enviado, podemos ver que é só

16:01 uma API padrão para um decision model. E a resposta bruta que recebemos de volta só nos dá as probabilidades, de novo, o padrão para um decision model aqui. Agora, o legal do Mercury Decide é que não só podemos fazer tudo isso com texto, certo? Também podemos fazer isso com imagens. Se eu fizer uma captura de tela desta interface e configurar para analisar uma captura de tela da interface, esta será a captura de tela de uma página depois que um usuário clicar em Pagar.

16:33 E então vamos ver: há algum erro? Parece que o pagamento foi concluído? E assim por diante. E vocês podem ver que a resposta chegou muito rápido. De várias maneiras, isso basicamente mostra que aquela é a nossa imagem, que na verdade é só uma captura de tela desta interface. Então, não há muita coisa relacionada a pagamentos nem nada disso, certo? Se tentarmos fazer algo como uma análise de imagem, este é um ótimo exemplo, acho, de como as pessoas poderiam usar isso. O que fiz aqui foi usar um gerador de imagens para criar algumas

17:03 imagens de catálogo que poderiam ser usadas em um site de comércio eletrônico ou algo assim. Em todas, o tipo de roupa é o mesmo. Em uma, há um homem; em outra, uma mulher; e na terceira, não há nenhuma pessoa. E vocês podem ver as perguntas que estou fazendo aqui. Tenho várias perguntas diferentes. Estou perguntando, por exemplo: há uma pessoa na imagem? É apropriada para o trabalho? É uma foto ou uma captura de tela? Qual é a qualidade? E coisas assim. Vamos executar e ver no que dá. E vocês já podem ver que terminou. Nem preciso pausar nem nada.

17:34 Então, essa era a foto, certo? É um homem usando uma roupa. Há uma pessoa: sim, 100%. Apropriada para o trabalho: sim, 99,8%. Tipo: foto. Pessoa: homem. E, quanto à qualidade, deu 3,7. Vou trocar esta imagem. Agora tenho basicamente a mesma roupa, mas com uma mulher. Vamos ver como fica. E vocês podem ver que praticamente todo o resto continuou igual. A única coisa que mudou foi ser uma mulher, certo?

18:07 E isso foi intencional. Queremos manter mais ou menos a mesma aparência aqui. Estamos mudando só um detalhe na imagem, mas o modelo consegue detectá-lo, e faz isso muito bem. Vou tentar uma última, em que temos a roupa, certo? A mesma roupa que aquelas duas pessoas estavam usando, mas agora não há ninguém vestindo-a. Vou executar, e vocês podem ver que, como esperado, o resultado é basicamente: presença de pessoa, 0%; continua apropriada para o trabalho — na verdade, até um pouco mais apropriada — e, em pessoa, indica que não há nenhum ser humano na imagem.

18:41 Então, essa capacidade de tomar decisões muito rapidamente se beneficia bastante de algo como diffusion, certo? Temos esse tempo de resposta muito rápido. Temos a capacidade de fazer várias perguntas diferentes e coisas do tipo. Até nos benchmarks deles, quando você faz umas 64 perguntas, o processo todo não fica muito mais lento. As respostas continuam extremamente rápidas. Para encerrar a demonstração, eu diria que, se vocês nunca experimentaram modelos de linguagem

19:12 de diffusion, é muito divertido. Tenho que dizer: é mesmo divertido ver como essas coisas funcionam rápido. E acho interessante como eles estão reunindo todas essas ideias de um jeito bem diferente dos modelos autorregressivos. Certo, uma coisa legal que vocês podem fazer é combinar os dois. Este é um exemplo de um pipeline que usa tanto o Mercury Decide quanto o Mercury 3. Vocês podem ver que temos algum tipo de chamado chegando, e o que ele vai fazer é realizar várias classificações, fazer

19:45 uma série de perguntas. Depois, vai usar o modelo de sistema dois, o Mercury 3, para redigir uma resposta. Vamos executar, e vocês vão ver que ele está usando o tempo de triagem para fazer as tarefas do decisor. Depois, o Mercury 3 entra em ação, e, no fim, há mais verificações. Neste caso, ele concluiu que o assunto era relacionado a cobrança. Concluiu que precisava de atenção imediata. É necessário responder. É uma solicitação de reembolso. Então, o Mercury 3 usou essas informações e conseguiu basicamente

20:20 redigir uma resposta muito rapidamente. Depois, podemos verificar de novo com o decision model, só para garantir que não fizemos algo como prometer demais, que não esteja faltando alguma coisa e para conferir o tom, esse tipo de coisa. Vocês podem ver que, neste caso, a resposta ficou neutra, mas aceitável, e um pouco mais calorosa. E, literalmente, em alguns segundos, tudo foi processado, verificado e classificado, entre outras coisas, muito rapidamente.

20:55 Certo, então onde esses modelos se encaixam? Bom, o Mercury 3 faz mais sentido em situações em que a latência se acumula. Por exemplo, agents, busca por voz, tutoria e coisas desse tipo. Este vai ser um modelo muito útil. Já o Mercury Decide faz sentido para verificações em grande volume. Por exemplo, moderação e encaminhamento, especialmente nos casos em que você pode usar o nível de confiança para encaminhar os casos incertos. Os dois modelos estão atualmente com preços de lançamento, então vale muito a pena conferir. E acho que, para concluir, o que a Inception fez

21:28 aqui foi mostrar que diffusion parece mesmo escalar para LLMs. Enfim, contem nos comentários se vocês já experimentaram esses modelos de linguagem diffusion. Se ainda não, recomendo muito testar o Mercury 3 e ver como ele funciona bem e, mais importante, com que rapidez ele consegue atender aos seus casos de uso. Como sempre, se acharam o vídeo útil, cliquem em curtir e se inscrevam, e nos vemos no próximo vídeo. Até lá!

Transcrição original

[00:00] Okay, so most of the big AI labs are racing in one direction, and that’s that they’re fully focused on intelligence. Every new release is about topping some other benchmark And really when it comes to speed, that’s not their main concern at all And for a long time, that’s basically just been the story with autoregressive models, right? You’re predicting one token at a time. Well, diffusion language models have been the exception here. They’ve always been much quicker than normal LLMs. But for a long time, they came with a trade-off.

[00:31] They just didn’t perform as well. You could kind of think of them as the fast little model that you could use for autocomplete, but not the model that you could hand a real agent task to Well, I’ve got to say with Mercury 3 and Mercury Decide, that’s all changed Mercury 3 itself runs at over 1,000 tokens a second. and on Inception’s benchmarks, it sits in the same range as GPT-6 Luna and Claude Haiku 5.5. So you’re not having to give up all your intelligence just to get speed anymore and Mercury 3 is not the only thing that they’ve been working on.

[01:04] alongside that, there’s Mercury Decide, which is their take on a Jev-style decision model and as I’m recording this, it’s currently free on OpenRouter Now, when Inception reached out to me to give me access to this early model and sponsor the video I was really curious to see just how far diffusion models have actually come for LLMs So in this video, I’m gonna go through the two models. We’ll look at benchmarks, both some from inception, But also some third-party ones, and I’m gonna show you some tests that I’ve run myself And actually see where

[01:35] diffusion language models are these days Okay, so if you don’t know anything about diffusion LLMs, let me explain a little bit about them. So how are they actually different? Well, most LLMs are autoregressive. you can kind of think of that as them writing like a typewriter. One token, then the next, then the next, and every single token costs a full pass through the model. That’s why decoding speed is so important. The diffusion on the other hand, works much more like an editor. They start with a rough masked out draft of the whole response and

[02:07] then they refine lots of tokens in parallel over a handful of passes so each pass does more useful work. and because inference is limited mostly by memory bandwidth and not compute, getting lots of tokens out of each parse is where the speed up actually comes from and if the idea of diffusion sounds familiar, it should, right? It’s the same basic idea behind most of the image and video generators that are out there now I gotta point out that’s why it’s no coincidence that Inception’s CEO, Stefano Ermon, is one of the co-inventors of some of the key

[02:42] diffusion methods behind modern image and video generation And the founding team at Inception have worked on techniques like this for quite a long time now, and many others that we use like DPO, flash attention, et cetera so this team is clearly a bunch of people who got diffusion early, And they’ve really been working hard for a while now to prove that this can work just as well for text, not just images And so the big question with diffusion LLMs has always been, do they scale? back at ICML in 2024, I attended Sander Dieleman’s diffusion circle

[03:17] and specifically asked him at the time about this. Did it look like diffusion was gonna take over LLMs just like it had done with image generation and video generation and even things like, music generation And at the time then it really was an open question. No one had been really able to show that these things could actually scale up to sizes where they became very strong language models, now Inception are really the ones who’ve shown that this can scale And it’s pretty cool that a reasonably small startup is actually doing this. so back at the start, they started with Mercury 1.

[03:49] They showed how you could build a commercial diffusion model and if you look at this chart, it really just shows what’s happened since. from Mercury 1 Mini to Mercury 3, they’ve scaled total parameters by more than 40X, and their intelligence average has gone up by 3X Now, the bit I find interesting is the jump from Mercury 2 to 2.5 was roughly the same size model. so it seems like that gain came from training, not scale. But then from 2.5 to 3, they’ve really scaled up to a much bigger model here.

[04:20] so both levers seem to be working for diffusion Which is exactly what we wanna see if we’re gonna see this take off. Don’t forget we’re talking about a startup that doesn’t have anywhere near the funds of the big players like OpenAI and Anthropic, et cetera okay, so how does Mercury 3 compare to models in its class? this is against basically GPT-6 Luna, Claude Haiku 5.5, Where it’s strong is in reasoning, instruction following, and search. It’s doing very well on GPQA Diamond there Infact You can see that it’s

[04:51] doing well on many of these benchmarks, including the agentic search benchmarks while it’s not at Opus 5.5 level for agentic coding, it’s still well-suited for medium-level tasks and as a default model for coding sub-agents And that whole idea of basically having like swarms of agents is really suited to this model. When you’ve got something so fast like this, you can deploy it for a whole bunch of different ideas like recursive self-improvement loops, understanding large code bases,

[05:22] And anything where you’ve got a really large amount of data that you want multiple sub-agents to go across and interpret that data and if you’re building something like a search agent or a support bot where following instructions really matters and speed matters, Mercury 3 is looking really strong here now that’s just comparing the intelligence benchmarks. If we start to look at speed, then Inception’s numbers really take off. So Mercury 3 can get 1,068 tokens a second on NVIDIA Blackwell if you can compare

[05:52] that to those other models, that’s about eight times what Luna gets, and even 4.5 what Claude Haiku is getting and as you’ll see in the demo that I show, this thing just flies at being able to generate text out And you also have the ability to turn the reasoning effort up and down and you’ll see just how quick that actually can make answers coming back Alright, so where does this actually matter? So Inception have a few early customers sharing numbers The one I like was OcTen, who do search on smart glasses Their search was taking about 80 milliseconds,

[06:26] so the model was the bottleneck there. With Mercury 3, The generation time is 0.9 seconds. and you can imagine on smart glasses anything that’s gonna take just a few seconds is suddenly gonna make people think that something is broken there. Now the price for this at launch is gonna be 10 cents in and 35 cents out per million tokens, which is actually 50% off. So it’s gonna be interesting to see how long they run that. So longer term it may be a little bit more expensive than Luna or Haiku but you’ve still got the advantage of things like cached inputs being 90% off

[06:58] And if your agent resends the same context every step, that’s going to really add up. so the idea is you’re paying for speed here, not saving on tokens Another example that they talked about was Tinyfish, who build web agents And in their blog post, they talk about other examples of people basically being able to do a lot more just because the model is so much faster and the cool thing here is that this is fully OpenAI compatible, so switching is basically just changing a base URL change. it supports tool calling, it supports structured outputs and they even support

[07:31] a context window of a million tokens up from 260K in their last model And it’s great to see also that they’ve made this very easy for people to try out. Not only is it available on their own API, it’s on OpenRouter, Base10, and Vercel okay, so Mercury 3 is the thinking model. It’s the system two side of things. But as I’ve been talking about on the channel for quite a while, a lot of things you want a really quick system one kind of decision That’s the whole sort of thing, like agents just needing really quick calls.

[08:03] Is this a billing ticket? Is an agent stuck? did a page actually load? And I’ve talked about it quite a lot on the channel, that that’s what decision models are for These models don’t generate any text at all. You give them some state and a question, and they give you back an answer and a probability in one call. so here’s where Mercury Decide fits in it’s a diffusion decision model you pass in a state and the cool thing about this is that can both be text but it can also be images as well. you pass in a set of typed questions And then the model will process all of that and return its answer in a

[08:36] fraction of a second, so how good is it? so rather than just take Inception’s word for it, let’s look at some of the independent evals for this one. Val’s AI ran it through the same test they used on Jev on claim verifications, it was already matching Jev. On LegalBench, Mercury Decide is clearly ahead scoring around 87% versus 74%. And here’s the cool thing. It costs about a quarter of what Jev does And there’s a free version that you can try on OpenRouter as well On artificial analysis decision index, this model is third

[09:10] on not hallucinating at 32%. And like I’ve talked about in the other videos about decision models, It really matters when you want a model that says it’s not sure instead of just guessing And then on speed, Valls measured a median of about 0.16 seconds for a single judgment and 0.4 seconds for 64 judgments so clearly a super use case with this is where you’re passing in one context and asking lots of questions about that at the same time now the new thing with the latest

[09:40] release of Mercury Decide is vision and I really think that this is a pattern a lot more agents are going to use. Cheap System 1 checks wrapped around a single System 2 call you save the expensive thinking for the parts that need it, and you get a confidence score at every step that you can use to escalate to a human if you need it Okay, so jumping into the demo here. I’ve put together a little app, for testing this out. and I’m gonna show you a number of different things in here that I think are really cool with this testing suite and with my normal testing suite. So first off, if you’ve never actually used a diffusion LLM, you’re probably

[10:13] gonna get a sort of shock at, one, how quick it is, but two, also just how it actually does the tokens. So let’s look at this. I’m gonna ask it to explain how diffusion language models differ from auto-regressive ones. So you’ll see that it’s gonna take a bit to kick off. I’ve got some settings over here. But you can see very quickly, look at it going, and you’ll notice also as it goes through, it’s already finished. okay. What we can do here is I’ve put in a feature to replay it and slow it back down. if I come in here and replay this, you can see I’ve got it step back,

[10:47] so we can see what actually happened at each frame, as we go along here. And you can see that it gradually sort of fixes things up, as it goes through. It works out different tokens, like, okay, how the different tokens should come together, and it’s very different, than just sort of like a standard LLM, right? In fact, I can scroll through this manually, so we can just slow it down and look at it. Right? So with a normal autoregressive LLM, once it’s committed to a token, it

[11:17] can’t really go back and change that. Now, there’ve been some papers that have tried different ways of backtracking and stuff like that, but fundamentally, it’s doing it step by step. Here you can see it starts to sort of plot out, like, a few different paragraphs, and then it goes through and actually sort of, refines this. So we can see that, as it’s going along, it’s working out, what should be at that start there. And so it had, when we go back here, it had at there, but it’s still–

[11:47] and it’s got auto something SemIf. but as we go through the frames, it starts to basically put it all together. and sure enough, it then assembles, whole, sorts of paragraphs, and, eventually, gets through and gets right to the end, where it’s assembled the whole response here. And you’ll see that the response reads perfectly, right? There’s nothing, unusual about the text, that the Diffusion LLM makes. It’s just how it makes it, is fundamentally different.

[12:20] So this is one of the first things that is really cool to actually see here is just the speed of how this happens. And you can just see there, that was so quick. Let me just run that again so you can see it. I’m not speeding anything up here. I’m just showing you the actual speed, right? It takes a little bit of time for the first tokens to come in, although it’s so quick I don’t even get a chance to say that. but fundamentally then it assembles it all, and it’s done very quickly in there. so this is the advantage of diffusion, right?

[12:51] And you’ll see if I give it one of my standard prompts about writing a 5,000-word essay, this is, still gonna take it a little bit of time. It’s 5,000 words, and you can see the time to first token there is, taking a little bit to get going. But as it goes through, it basically puts all of this together, and gives this out. And if I speed up down here, we can see it’s still assembling, the end of the document. So it’s going through in chunks, putting it together. But this model is actually very good at being able to put the whole thing together.

[13:23] So in my tests so far, I don’t find it doing the things that a lot of the open models do of where they only write half of the essay or, they prompt it to, “Oh, if I was gonna continue, I would get to this and this and this kind of thing.” so that’s one of the interesting things here And you can see if I come in and actually paste, that output in here, it’s 4,200 words, so that’s certainly a lot better than a lot of the models are producing out All right. If we come across to my normal sort of testing ground here, we can try

[13:54] it out also on things like the, standard agentic tool calling stuff. And you’ll see that look, it’s just going through it all so quickly that, there are 10 tests in here, and often it would take quite a long time for an autoregressive model to do this. and I actually sort of pause it usually. I’m not getting a chance to pause it here. It’s gone through, got 10 out of 10, done really nicely on them. No sort of overthinking that we see on some of them in there If I come down and give it the sort of, pro ones, again, the speed of

[14:26] the responses, is really good here. So, this is doing, really well, and this is one of the things that we saw, even some of the meta models having issues with, some of the things in here. But I’m gonna let that go through. it’s gone through and it’s basically passed all eight of them, perfectly, right? so this is one of the cool things about this model, right? That it can do all those kinds of things. And for things like RAG, it does a really nice job. You can see it’s gone through, very quickly doing, 4,000 tokens, going through

[14:56] there to basically get the right answers. It was doing input to be able to extract things out So that one’s Mercury 3, which is their system two model, right? That’s basically where all the intelligence is, where it’s doing a lot of thinking, reasoning, that kind of thing If we change over to Mercury Decide, we’ve now got the System 1 model. and this is basically where you’ve got all your Jev-style decision model, things going on in here. So we can run things like a support ticket through this And you’ll see

[15:29] the crazy thing here is literally I’m almost just pressing it, and it’s giving me the answer back, so quickly. so I will basically let it go, and you can see, okay, there it’s gone through. It’s basically done the classifications on this test. we’ve got the normals, we’ve got the choices, we’ve got, a score, in here. And the model’s done really well there. we can also see the confidence scores for things like choice and for things like, the score and stuff in there. if we want to see actually what got sent in there, we can see that’s just

[16:01] a standard, API for a decision model. and then our raw response back is just giving us the probabilities, again, the standard for a decision model in here Now the cool thing about Mercury Decide is not only can we do all of that with text, right? We can also do it with images If I take a screenshot of this UI, and basically I’m setting it to actually do a UI screenshot, This is gonna be the screenshot of a page after a user has clicked Pay.

[16:33] and then we’re gonna see, does it have an error? Does it look like the payment went through, et cetera? And you can see the response back there was super quick. and many ways, this is basically, showing, that’s our image there, which is actually just a screenshot of this UI. So really there’s not a lot related to payments or anything, like that there Right. If we try and do something like an image check, this is a really good, example I think of how people could use this. So what I’ve done here is I’ve used an image generator to make up some,

[17:03] catalog pictures that would go on like an e-commerce site or something like that. Each of them is the same kind of outfit. One is with a male, one is with a female, one is with no human at all. And you can see the questions I’m asking in here. I’ve got a whole bunch of different questions in there. I’m asking it about, like, is there a human in there? Is it safe for work? a photo, a screenshot? what’s the quality? And stuff like that. Let’s just run it and see how it goes. And you can see already it’s done. I don’t even need to pause or anything with this.

[17:34] So that was the photo, right? It’s a guy in an outfit there. Has a person, 100% yes. Safe for work, 99.8% yes. kind equals photo. person equals man. and then quality, it’s giving us 3.7 there. Let me swap out this image So now I’ve got basically the same outfit, but a woman in there. Let’s see how this one goes And you can see pretty much everything else stayed the same. the only thing that changed was a woman, right?

[18:07] and that was quite deliberate. Like, we wanna have the same sort of look in here. We’re just changing one little thing in the actual image, but the model’s able to detect that and detect it really well Let me try a last one where we’ve got the outfit, right? The same outfit that those two people were wearing, but now there’s no human actually wearing this. Let me run it and you can see sure enough, it’s basically has person is 0%, still safe for work, in fact, slightly more safe, and then person, no human, in there.

[18:41] so this ability to do these decisions really quickly really benefits from something like diffusion, right? You’ve got that, really fast response time. You’ve got the ability to ask lots of different questions and stuff in here Even in their benchmarks, when you ask sort of 64 questions, it’s not really slowing the whole process down, too much. It’s still extremely quick with its responses So just to wrap up the demo, the thing I would say is if you’ve never played with, diffusion language

[19:12] models before, it’s a lot of fun. I gotta say it really is just fun to see how quick these things work. And I find it interesting how they’re putting their whole sort of ideas together, in a very different way than autoregressive models All right, so one cool thing that you can do is put these together. So this is an example of a pipeline that’s using both Mercury Decide and Mercury 3 in here. So you can see that, we’ve got some kind of ticket going in, and what it’s gonna do is basically do a bunch of classifications, go

[19:45] through, ask a bunch of questions. Then it’s gonna use the system two model, Mercury 3, to actually draft a response. So let’s run this, and you’ll see that, it is actually spending the triage time of doing the decider stuff. Then it’s got the Mercury 3 running, and then it’s got more, checking at the end. So for this, it worked out that it was billing related. it worked out that it needed immediate attention. it needs a reply. it’s a refund request. And then the Mercury 3 came in with that information, was able to basically

[20:20] draft a reply, very quickly, and then we can then check it again with the decision model just to make sure, did we do anything like overpromise? is there anything that’s sort of, not in there? What is the tone like? That kind of thing. So you can see that in this case, we’ve basically got it where we got a, a flat but acceptable to a bit of a warmer response back And in literally in a couple of seconds here, we’ve had the whole thing, be processed, checked, classified, all these sorts of things, in a really fast time

[20:55] Alright, so where do these actually fit? Well, Mercury 3 makes most sense anywhere latency compounds. So agents, voice search, tutoring, all those kinds of things. this is gonna be a really useful model Mercury Decide on the other hand makes sense for high volume checks. So anything like moderation, routing, and especially anything where you can use the confidence score to escalate the uncertain cases Both models are currently on launch pricing right now, so definitely worth checking out And I think in closing, really what Inception has

[21:28] done here is that they show that diffusion does seem to scale for LLMs. Anyway, let me know in the comments if you’ve actually tried out these diffusion language models. If you haven’t, I really suggest trying Mercury 3 out and just seeing how well and more importantly, how quickly it can actually work for your use cases as always, if you found the video useful, please click like and subscribe, and I will talk to you in the next video. Bye for now