Mercury 3 é INSANO: testei 13 exemplos ao vivo (+ 100 milhões de tokens grátis)

Autoria: Prompt Engineer 48 · 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: Mercury 3 Is INSANE: I Tested 13 Live Examples (+ 100 MILLION FREE Tokens) · Canal: Prompt Engineer 48 · 09:50 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Engenharia de software com IA, Ferramentas de desenvolvimento com IA, Modelos de IA

Resumo

O vídeo testa o Mercury 3, da Inception Labs, em tarefas de programação, lógica, tradução, geração de interfaces e classificação. O apresentador destaca respostas rápidas e bons resultados em vários exemplos, mas observa que tarefas mais complexas demoram mais e que algumas saídas não foram verificadas. Em testes próprios via API, mediu cerca de 260 a 420 tokens por segundo de ponta a ponta, abaixo dos mais de 1.000 tokens por segundo divulgados pela empresa. Ele também comenta a oferta de 100 milhões de tokens grátis e recomenda testar o modelo por conta própria.

Pontos-chave

O Mercury 3 é apresentado como um diffusion language model que refina uma resposta inteira em várias passagens, em vez de gerar um token por vez da esquerda para a direita.
Segundo a documentação mencionada no vídeo, novas contas recebem 100 milhões de tokens grátis, sem precisar cadastrar dados de pagamento.
O modelo gerou jogos e ferramentas interativas, incluindo Snake, Game of Life, um quadro Kanban, um playground de regex e um visualizador de algoritmos de ordenação.
Em tarefas de texto, resolveu corretamente um problema de lógica e produziu uma explicação de relatividade especial em poucos segundos.
O apresentador considerou promissores os testes de refatoração e geração de testes, mas não executou os testes para confirmar que estavam corretos.
O tempo de resposta variou: tarefas mais complexas levaram mais tempo, e algumas execuções do mesmo prompt tiveram durações diferentes.
Nos testes via API com streaming, a velocidade observada de ponta a ponta ficou entre aproximadamente 260 e 420 tokens por segundo.
O apresentador ressalta que os números de preço e desempenho divulgados pela página são alegações do fornecedor e recomenda fazer testes próprios.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do Mercury 3 e da oferta grátis	O apresentador introduz o modelo, explica a abordagem de difusão e mostra como obter tokens grátis e acessar a API.
02:06	Testes de texto, lógica e programação	Os exemplos incluem comparação do efeito visual, geração de um texto longo, resolução de um problema de lógica e refatoração de código.
04:08	Aplicações interativas e tradução	O vídeo testa jogos e interfaces, além de tradução, geração de uma página de produto e criação de um playground de regex.
06:38	Visualizador de ordenação e modo de decisão	O apresentador mostra um visualizador de algoritmos, uma explicação simples de relatividade e o modo de classificação rápida.
08:14	Medições via API e veredito	Os testes de streaming ficam abaixo da alegação de 1.000 tokens por segundo, e o apresentador encerra com ressalvas e recomendações para testar o modelo.

Citações

Um prompt, aperto Enter, e um jogo de Snake inteiro aparece em poucos segundos. — 00:00

É bonito de assistir, mas desligue o efeito se quiser a resposta mais rápida. — 02:06

Estou chamando isso de promissor, não comprovado. — 03:07

De ponta a ponta, vi algo em torno de 260 a 420. — 08:44

Não tome o número de marketing como promessa para o seu próprio app. — 09:14

Conceitos e entidades

Mercury 3 (modelo): Modelo da Inception Labs testado no vídeo em tarefas de geração de texto, código e classificação.
Inception Labs (empresa): Empresa responsável pelo Mercury 3 e pelas alegações de desempenho mencionadas no vídeo.
diffusion language model (conceito): Abordagem descrita no vídeo em que o modelo começa com um rascunho da resposta e o refina em várias passagens.
GPT-6 (modelo): Modelo citado em alegações comparativas de desempenho e preço atribuídas à página do Mercury 3.
Luna (modelo): Modelo mencionado em comparações apresentadas no vídeo.
Claude Haiku 5.5 (modelo): Modelo citado no anúncio da Inception Labs como comparação de desempenho.
RunPod (empresa): Serviço que o apresentador recomenda para quem procura GPUs.

Tradução completa (pt-BR)

00:00 Veja só. Digito um prompt, aperto Enter e, em poucos segundos, aparece um jogo da cobrinha completo. Código à esquerda, uma prévia funcional à direita. Este é o Mercury 3, da Inception Labs, um modelo de linguagem de difusão. >> [música] >> O blog diz que ele roda a mais de 1.000 tokens por segundo e que você ganha 100 milhões de tokens grátis para experimentar. Então, hoje não vou ler um comunicado à imprensa para vocês. Vou enviar prompts reais para ele ao vivo e contar exatamente o que funcionou e

00:31 o que não funcionou. Vamos lá. Primeiro, o que um modelo de difusão faz de diferente? Modelos de linguagem normais escrevem um token por vez, da esquerda para a direita. O Mercury começa com um rascunho de toda a resposta e refina tudo de uma vez, em algumas passagens, como uma foto que vai ficando nítida. A publicação de lançamento, divulgada em 19 de outubro, diz que o Mercury 3 supera GPT-6, Luna e Claude Haiku 5.5, sendo de 4 a 8 vezes mais rápido. Lembre-se: essa é a

01:01 alegação do fornecedor. Tudo o que vem depois deste ponto é o que vi na minha própria tela. Agora, a parte grátis. A documentação diz que cada conta nova recebe 100 milhões de tokens grátis, sem precisar informar dados de pagamento. Você entra na plataforma, abre API keys, cria uma chave e pronto. O nome do modelo é Mercury 3, e o endpoint segue o padrão da OpenAI. Então, a maioria dos clientes existentes simplesmente funciona. Depois dos tokens grátis, o blog informa o preço de 20 centavos por milhão de tokens de entrada e 70 centavos por milhão de tokens de saída, com uma promoção de lançamento que

01:32 corta esses preços pela metade. Certo, chega de conversa sobre configuração. Exemplo um: o jogo da cobrinha. Prompt: Crie um jogo da cobrinha completo em um único arquivo HTML. Olhe para o lado esquerdo. O texto fica borrado por um instante e depois fica nítido. Esse é o efeito de difusão, de 4 a 5 segundos depois. O arquivo está pronto e o jogo está rodando. E sim, eu joguei. Ele começa, se movimenta, marca pontos e termina com a mensagem de fim de jogo quando bato na parede.

02:06 Exemplo dois: há uma opção para ativar o efeito de difusão no canto. Ela muda a forma como o texto aparece. Então, eu quis saber se isso muda a velocidade. O mesmo prompt: Explique como funciona um transformer em 300 palavras, uma vez com o efeito desligado e outra com ele ligado. Fiz cada teste três vezes. Com o efeito desligado, terminou em cerca de 1 segundo e meio a 2 segundos. Com ele ligado, levou 3 segundos e meio em todas as vezes. Então, a opção é um efeito visual e, na verdade, custa um ou dois segundos. É bonito de assistir, mas desligue se quiser a resposta mais rápida.

02:36 Exemplo três: um texto longo. Pedi um post de blog de mil palavras, com títulos e uma conclusão. Cerca de 6 segundos e meio depois, o post inteiro estava ali. Textos longos são exatamente onde um modelo normal faz você esperar. Então, este pareceu diferente. Exemplo quatro: um problema de lógica com resposta conhecida. Alice tem o dobro da idade que Bob tinha quando Alice tinha a idade que Bob tem agora, e a soma das idades deles é 63. O modelo montou as equações, resolveu em menos de 3 segundos e disse: “Alice tem 36 anos e Bob

03:07 tem 27.” Está correto. Ele até conferiu a própria resposta. Nove anos atrás, Alice tinha 27 e Bob tinha 18, e 36 é o dobro de 18. Muito bem. Exemplo cinco: trabalho real com código. Passei para ele uma função confusa, com um loop e um índice, e pedi que a refatorasse e adicionasse testes bem rigorosos. Foram 4 segundos. Ele devolveu uma versão limpa, além de um arquivo completo de testes: lista vazia, números negativos, zero, duplicatas, ordem preservada e até uma entrada do tipo gerador. Eu mesmo ainda não executei esses testes, então considero isso

03:38 promissor, mas não comprovado. Exemplo seis: uma armadilha. Pedi o preço de fechamento exato das ações da Nvidia ontem. Um modelo simples chutaria. Este pesquisou 12 fontes, apresentou um valor em cerca de 5 segundos e apontou que um site discordava por 8 centavos. Não verifiquei esse número, então não negocie com base no meu vídeo, mas apontar uma divergência é o comportamento certo. Exemplo sete: o Jogo da Vida de Conway

04:08 com uma tela de desenho e botões para iniciar, pausar e avançar uma etapa. Na minha primeira tentativa, levou 10 segundos; na segunda, cerca de 23. O mesmo prompt, uma carga diferente, então considere qualquer número isolado com cautela.

04:40 Exemplo oito: o teste de estresse, um quadro Kanban com arrastar e soltar, opção para adicionar e excluir cartões e salvamento no armazenamento local. Foram 44 segundos na primeira tentativa e 28 na segunda. O modelo passa boa parte desse tempo pensando antes de escrever. Quando terminou, havia um quadro de três colunas com cartões preenchidos. Então, a velocidade não é constante. Prompts mais difíceis demoram mais.

05:15 Exemplo nove: tradução para espanhol, hindi e japonês em menos de 3 segundos. Na primeira leitura, as três traduções me pareceram fluentes, mas eu gostaria que falantes nativos as avaliassem. Exemplo dez: uma página inicial futurista para um produto inventado, o Mercury Cloud Hero, com três cartões de recursos e preços. Levou cerca de 13 segundos. E olhem a prévia: um título, uma chamada para ação e até um pequeno cartão de terminal com um registro de deploy. Eu não pedi o terminal; ele simplesmente adicionou um.

06:03 >> Exemplo onze: um ambiente para testar regex com destaque de correspondências em tempo real. Este levou cerca de 27 segundos. Quando terminou, havia um campo para o padrão, botões predefinidos para e-mail, URL, data e outros, um texto de exemplo e opções para alternar flags. Uma ferramenta de verdade, criada a partir de uma frase.

06:38 Exemplo 12: um visualizador de ordenação com bubble sort, merge sort e quicksort, além de um controle deslizante de velocidade. Cerca de 21 segundos, e agora ele está ordenando ao vivo. Comparações, trocas e tempo decorrido, tudo se atualizando. As barras coloridas mostram o algoritmo em execução.

07:11 E mais um teste rápido com texto simples: explique a relatividade especial para uma criança de 10 anos em cinco parágrafos curtos. Menos de 4 segundos. Não é código, não é uma ferramenta, só um texto claro. Agora, algo diferente. Na área de chat, há um modo Decide. A ideia é que, em vez de escrever texto, o modelo tome decisões rápidas de classificação. A opção predefinida é triagem de suporte, com um cliente que foi cobrado duas vezes e está irritado. Apertei Decide. Ele respondeu a quatro perguntas

07:42 de uma vez: quer reembolso? Sim. Equipe responsável: cobrança. Grau de irritação: pouco mais de dois e meio em três. Risco de cancelamento: sim. E a página diz que ele tomou a decisão em 186 milissegundos. A página estima um custo de cerca de 1 centavo por mil chamadas e afirma que o preço de entrada é 80% menor que o do GPT-6 Luna. Esses valores de custo são da página, não meus, mas a velocidade, essa parte eu vi acontecer. Também há um modo de voz e um ambiente de busca. Não testei a voz para este vídeo e não vou fingir que testei. A context window de 1 milhão de tokens também

08:14 não foi testada, então não vou fazer nenhuma afirmação a respeito. Agora, a parte que consigo verificar direito: peguei a API key e chamei o Mercury 3 por conta própria, com streaming. Não se preocupem, não vou mostrar a chave e vou trocá-la depois deste vídeo. Primeira execução: uma explicação de 250 palavras, com raciocínio médio. O primeiro token chegou após 2,8 segundos; o total foi de 3,1 segundos. Foram 806 tokens, ou cerca de 258 tokens por segundo do início ao fim. Segunda execução: 600 palavras com esforço de raciocínio baixo. 1.968

08:44 tokens em 4,7 segundos, cerca de 416 por segundo. Terceira execução: o mesmo prompt, com esforço médio; 3 segundos no total, cerca de 353 por segundo. Então, onde estão os mil tokens por segundo? Duas coisas. Cerca de um terço a metade desses tokens de conclusão eram tokens de raciocínio ocultos, e o texto chega em rajadas. Se você medir apenas o intervalo depois do primeiro token, os números ficam enormes. Do início ao fim, vi algo entre 260 e 420. Ainda é rápido, mas não é o que diz a manchete. Foram execuções únicas na minha rede, então os seus números vão variar. A conclusão

09:14 é simples: respostas rápidas, ferramentas, classificação e ajuda com código — parece instantâneo. Não trate o número de marketing como uma promessa para o seu próprio app. Então, aqui vai meu veredito. Do que gostei: a velocidade em textos longos, o problema resolvido corretamente, o código e os testes sólidos e o fato de ele ter apontado a própria divergência no preço das ações. O que eu observaria: o número da manchete, os tokens de raciocínio ocultos e tudo o que não testei. Se quiser experimentar, os tokens grátis são o grande atrativo. Crie uma conta, pegue uma chave e rode seus próprios prompts. Não acredite só na minha palavra nem na do blog.

09:50 Se estiver procurando GPUs baratas e confiáveis, eu uso RunPod, e o link está na descrição. Me contem nos comentários: qual é a primeira coisa que vocês testariam com o Mercury 3? Vejo vocês no próximo vídeo.

Transcrição original

[00:00] Watch this. I type one prompt, hit enter, and a whole snake game shows up in a few seconds. Code on the left, a working preview on the right. This is Mercury 3 from Inception Labs, a diffusion language model. >> [music] >> The blog says it runs at over 1,000 tokens per second, and you get 100 million free tokens to try it. So, today I’m not reading you a press release. I am throwing real prompts at it live, and I will tell you exactly what held up and

[00:31] what did not. Let’s go. First, what is a diffusion model doing differently? Normal language models write one token at a time, left to right. Mercury starts with a rough draft of the whole answer and refines all of it at once, a few passes, like a photo coming into focus. The launch post, published October 19th, says Mercury 3 beats GPT-6, Luna, and Claude Haiku 5.5, while running 4 to 8 times faster. Remember, that is the

[01:01] vendor’s claim. Everything after this point is what I saw on my own screen. Now, the free part. The docs say every new account gets 100 million free tokens, and no payment details are needed. You sign in on the platform, open API keys, create a key, and you’re in. The model name is Mercury 3, and the endpoint is OpenAI style. So, most existing clients just work. After the free tokens, the blog lists 20 cents per million input tokens and 70 cents per million output, with a launch promo that

[01:32] cuts that in half. Okay, enough setup chat time. Example one, the snake game. Prompt: Write a complete snake game in one HTML file. Watch the left side. The text is blurry for a moment, then it sharpens. That is the diffusion effect, 4 to 5 seconds in. The file is done, and the game is running. And yes, I played it. It starts, it moves, it scores, and it ends with game over when I hit the wall.

[02:06] Example two, there is a diffusion effect toggle in the corner. It changes how the text appears. So, I wanted to know if it changes the speed. Same prompt. Explain how a transformer works in 300 words, once with the effect off, once on. I ran each three times. With the effect off, it finished in about 1 and 1/2 to 2 seconds. With it on, 3 and 1/2 every single time. So, the toggle is a visual effect and it actually costs you a second or two. Pretty to watch, but turn it off if you want the fastest answer.

[02:36] Example three, a long one. I asked for a thousand word blog post with headings and a conclusion. About 6 and 1/2 seconds later, the whole post was sitting there. Long outputs are exactly where a normal model makes you wait. So, this one felt different. Example four, a logic puzzle with a known answer. Alice is twice as old as Bob was when Alice was as old as Bob is now, and their ages add up to 63. It set up the equations, solved them in under 3 seconds, and said, “Alice is 36 and Bob

[03:07] is 27.” That is correct. It even checked itself. 9 years ago, Alice was 27 and Bob was 18, and 36 is twice 18. Good. Example five, real code work. I passed it a messy function with a loop and an index, and asked it to refactor it and add pedantic tests. 4 seconds. It gave back a clean version, plus a full test file, empty list, negatives, zero, duplicates, order preserved, even a generator input. I have not run those tests myself, so I’m calling this

[03:38] promising, not proven. Example six, a trap. I asked for the exact closing price of Nvidia stock yesterday. A plain model would guess. This one searched 12 sources, gave a figure in about 5 seconds, and pointed out that one site disagreed by 8 cents. I did not verify that number, so do not trade on my video, but flagging a disagreement is the right behavior. Example seven, Conway’s Game of Life

[04:08] with a canvas, play, pause, and step buttons. This one took 10 seconds on my first run, and about 23 on the second. Same prompt, different load, so treat any single number with care.

[04:40] Example eight, the stress test, a Kanban board with drag and drop, add card, delete card, saved in local storage. 44 seconds on the first run, 28 on the second. The model spends a lot of that time thinking before it writes. When it finished, there was a three-column board with seated cards. So, the speed is not constant. Harder prompts take longer.

[05:15] Example nine, translation, Spanish, Hindi, and Japanese in under 3 seconds. All three came out fluent to me on the first read, but I would want native speakers to judge them. Example 10, a futuristic landing page for a made-up product, Mercury Cloud Hero, three feature cards, pricing about 13 seconds, and look at the preview, a headline, a call to action, even a little terminal card with a deploy log. I did not ask for the terminal, it just added one.

[06:03] >> Example 11, a regex playground with live match highlighting. This one took about 27 seconds. When it finished, there is a pattern box, preset buttons for email, URL, date, and more, a sample text, and flag toggles. A real little tool from one sentence.

[06:38] Example 12 is sorting visualizer bubble, merge, and quick sort with a speed slider. About 21 seconds, and now it is sorting live. Comparisons, swaps, elapsed time, all updating. The colored bars are the algorithm running.

[07:11] And one quick plain text test, explain special relativity to a 10-year-old in five short paragraphs. Under 4 seconds, not code, not a tool, just clear writing. Now something different. Inside the chat side, there is a decide mode. The idea is instead of writing text, the model makes fast classification decisions. The preset is support triage with a customer who was charged twice and is angry. I hit decide. It answered four questions

[07:42] at once, want a refund, yes, team billing agency, a little over two and a half out of three, churn risk, yes. And the page says it decided in 186 milliseconds. The page estimates about 1 cent per thousand calls and claims 80% lower input price than GPT-6 Luna. Those cost figures are the pages, not mine, but the speed, that part I watched happen. There is also a voice mode and a search playground. I did not test voice for this video and I will not pretend I did. The 1 million token context window is

[08:14] also untested, so I will not claim anything about it. Now, the part I can verify properly, I took the API key and called Mercury 3 myself with streaming. Do not worry, I’m not showing the key and I will rotate it after this video. Run one, a 250 word explainer at medium reasoning. First token after 2.8 seconds, total 3.1 seconds. 806 tokens, that is about 258 tokens per second end-to-end. Run two, 600 words at low reasoning effort. 1,968

[08:44] tokens in 4.7 seconds, about 416 per second. Run three, same prompt at medium, 3 seconds total, about 353 per second. So, where is the thousand tokens per second? Two things. About a third to a half of those completion tokens were hidden reasoning tokens and the text arrives in bursts. If you only time the stretch after the first token, the numbers look huge. End-to-end, I saw roughly 260 to 420. That is still fast, but it is not what the headline says. These were single runs from my network, so your numbers will vary. The takeaway

[09:14] is simple, quick answers, tools, classification, coding help, it feels instant. Do not take the marketing number as a promise for your own app. So, here’s my verdict. What I liked, the speed on long outputs, the correct puzzle, solid code and tests, and that it flagged its own disagreement on the stock price. What I would watch, the headline number, the hidden reasoning tokens, and everything I did not test. If you want to try it, the free tokens are the whole point. Make an account, grab a key, and run your own prompts. Do not take my word or the blog’s.

[09:50] If you are looking for cheap and reliable GPUs, I use RunPod, and the link is in the description. Tell me in the comments, what is the first thing you would throw at Mercury 3? I will see you in the next one.