Claude Haiku 5.5 vs. Qwen 3.8 27B local: ainda vale a pena usar IA local?

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: Claude Haiku 5.5 vs Local Qwen 3.8 27B: Is Local AI Still Worth It? · Canal: Zero to MVP · 07:43 · Assistir no YouTube

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

Resumo

O vídeo compara Claude Haiku 5.5, acessado pela API da Anthropic, com Qwen 3.8 27B executado localmente em quatro tarefas: duas pequenas, uma alteração complexa em um editor de Markdown e a análise de documentos financeiros. Haiku foi mais rápido e passou em todos os testes; Qwen teve resultados equivalentes nas tarefas menores e nos documentos financeiros, mas falhou em alguns testes da tarefa de código mais difícil. O teste também destaca o custo elevado de Haiku em uma solicitação que ultrapassou o limite de contexto tarifado e o tempo e consumo de energia do modelo local. A conclusão é que modelos na nuvem são preferíveis para mudanças complexas em projetos grandes, enquanto modelos locais são úteis para tarefas menores e dados sensíveis, pois estes não precisam sair do computador.

Pontos-chave

Haiku concluiu as quatro tarefas sem falhas nos testes, enquanto Qwen teve resultados equivalentes em três delas, mas falhou em parte dos testes da tarefa mais complexa.
Na tarefa de dividir despesas, os dois modelos passaram nos 32 testes; Qwen levou quase nove vezes mais tempo.
Na correção do contador de palavras e caracteres do Textodus, Qwen falhou em um teste relacionado à contagem de sílabas coreanas.
Na atualização de links após mover ou renomear arquivos, Haiku passou nos testes ocultos e nos testes existentes; Qwen deixou de atualizar um link em um documento aberto.
A execução da tarefa complexa com Haiku custou US$ 1,44; a tarifa mais alta foi aplicada após solicitações ultrapassarem 100 mil tokens.
Qwen levou quase duas horas na tarefa complexa e consumiu cerca de 400 Wh, estimados em 15 centavos de eletricidade, sem incluir o custo do hardware.
Na análise dos documentos financeiros, ambos passaram nos 32 testes e evitaram incluir dados pessoais sensíveis nos arquivos de saída.
A privacidade é apresentada como um argumento importante a favor dos modelos locais, pois os documentos usados com Qwen não saíram do computador.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação e método de comparação	O vídeo apresenta Haiku 5.5 e Qwen 3.8 27B e explica como os dois modelos serão testados nas mesmas tarefas.
01:03	Utilitário Python e primeira tarefa no Textodus	Os modelos dividem despesas entre amigos e, em seguida, corrigem a contagem de palavras e caracteres no editor Textodus.
02:06	Alterações complexas em um projeto real	O teste de atualização de links no Textodus revela diferenças de qualidade, tempo e custo entre os modelos.
05:42	Documentos financeiros, privacidade e conclusão	Os modelos organizam documentos financeiros com dados sensíveis, e o autor conclui que a nuvem é melhor para mudanças complexas, enquanto o modelo local é útil para tarefas menores e privadas.

Citações

Em termos de qualidade, o resultado é o mesmo, mas a diferença de tempo já é significativa. — 01:35

O projeto compila, todos os testes existentes passam, mas um dos recursos principais funciona incorretamente. — 04:41

Com Qwen, os documentos nunca saíram do meu computador. — 06:43

Se eu precisar fazer mudanças sérias em um projeto grande, por enquanto vou usar modelos na nuvem. — 07:13

Poder trabalhar com seus dados sem enviá-los para a nuvem é outra história. — 07:43

Conceitos e entidades

Claude Haiku 5.5 (modelo): Modelo da Anthropic testado por meio da API em tarefas de programação e análise de documentos.
Qwen3.8 27B (modelo): Modelo de 27 bilhões de parâmetros executado localmente e comparado com Haiku.
Pi Agent (ferramenta): Agent usado para executar as tarefas com os dois modelos e as mesmas ferramentas.
Textodus (ferramenta): Editor de Markdown do autor, usado como projeto real nos testes de programação.
Anthropic (empresa): Empresa cuja API foi usada para executar Claude Haiku 5.5.
llama.cpp (ferramenta): Software usado para executar Qwen localmente com quantização Q4.
Obsidian (ferramenta): Aplicativo citado como referência para atualizar automaticamente links após mover ou renomear arquivos.
modelos locais (conceito): Modelos executados no computador do usuário, permitindo trabalhar com dados sem enviá-los a um serviço na nuvem.
Janela de contexto e tarifa por tokens (conceito): O vídeo relata que solicitações de Haiku acima de 100 mil tokens custaram cinco vezes mais e que o histórico do agent pode aumentar o consumo.
testes ocultos (conceito): Testes preparados antes da execução e mantidos fora do alcance dos modelos para avaliar seus resultados.

Tradução completa (pt-BR)

00:00 Na semana passada, a Anthropic lançou o Claude Haiku 5.5. É o modelo mais rápido e barato da empresa: custa apenas 10 centavos por milhão de tokens de entrada. Com preços assim, surge uma pergunta interessante: por que executar modelos locais no seu próprio computador? Decidi descobrir. Peguei o Haiku 5.5 e um Qwen 3.8 local com 27 bilhões de parâmetros e dei a eles as mesmas tarefas, desde uma pequena ferramenta em Python até corrigir bugs no meu aplicativo real e trabalhar com documentos financeiros pessoais. Os resultados acabaram sendo

00:32 interessantes. Em algumas tarefas, o Qwen se saiu tão bem quanto o Haiku. Em outras, levou várias vezes mais tempo e não percebeu bugs que ele próprio deixou passar. Vamos ver o que aconteceu. Para os testes, estou usando o Pi Agent. Os dois modelos trabalham com as mesmas ferramentas, sem extensões extras e no nível máximo de raciocínio. Escrevi os testes com antecedência. Os modelos não podem vê-los, e só os executo depois que o modelo diz que terminou. O Haiku é executado pela API da Anthropic. O Qwen roda no meu desktop, com uma Radeon Pro com 32 GB

01:03 de memória de vídeo. O modelo roda no Llama CPP com quantização Q4. Configurei o contexto para 192.000 tokens. Então, vamos começar. A primeira tarefa é escrever uma ferramenta em Python que divida as despesas compartilhadas entre amigos e calcule quem deve quanto a quem. À primeira vista, nada difícil, mas escondi 12 armadilhas na especificação. Por exemplo, o dinheiro não pode ser armazenado como números de ponto flutuante. Os centavos restantes têm que ser distribuídos de acordo com uma regra específica. E, no

01:35 fim do documento, há mudanças feitas após a revisão que cancelam alguns dos requisitos anteriores. Vamos começar pelo Haiku. Ele terminou em 3 minutos e meio e gastou menos de 4 centavos. As 32 verificações passaram. Agora, o Qwen. Ele também passou nas 32 verificações, sem nenhum erro, embora tenha trabalhado por meia hora, quase nove vezes mais. Então, em termos de qualidade, o resultado é o mesmo, mas a diferença de tempo já é significativa. Agora, vamos passar para um projeto real. Eu

02:06 tenho um editor de Markdown para desktop chamado Textodus. Ele tem mais de 20.000 linhas de código, algumas delas em Rust. A primeira tarefa é corrigir a contagem de palavras e caracteres. Atualmente, o texto em chinês é contado como uma única palavra, e alguns emojis, como uma bandeira ou uma família, são contados como vários caracteres. Dei aos dois modelos o texto simples da issue, sem nenhuma explicação extra. O Haiku corrigiu tudo em 8 minutos e custou 16 centavos. Todos os 13 testes ocultos passaram. O Qwen também

02:36 resolveu a tarefa em grande parte, mas um teste falhou. Ele decidiu contar cada sílaba coreana como uma palavra separada, embora o coreano separe as palavras com espaços. Como resultado, uma frase de duas palavras virou sete palavras. Um erro pequeno, mas ainda assim um erro. Agora, uma tarefa mais difícil. O Textodus tem um problema: se você renomeia ou move um arquivo, os links para ele em outras notas deixam de funcionar. Quero que eles sejam atualizados automaticamente, mais ou menos como no Obsidian. Há várias nuances aqui.

03:06 Links dentro de blocos de código não podem ser alterados. Se um documento estiver aberto e tiver alterações não salvas, não dá para simplesmente sobrescrevê-lo no disco. E, quando uma pasta é movida, os links relativos precisam ser tratados corretamente. Certo, primeiro o Haiku. Ele trabalhou por 22 minutos e deu 81 passos. Todos os meus 13 testes ocultos passaram, assim como os 530 testes existentes no projeto. Mas o custo acabou sendo surpreendentemente alto: 1 dólar e 44 centavos. A questão é que o Haiku 5.5 tem

03:38 um limite de 100.000 tokens por solicitação. Se você ultrapassa esse limite, a solicitação inteira custa cinco vezes mais. E um agent trabalhando em um projeto grande continua enviando ao modelo todo o histórico do trabalho. No meu caso, 58 solicitações ultrapassaram esse limite. Sem a tarifa mais alta, a tarefa teria custado cerca de 32 centavos. Então, vale a pena ter isso em mente ao usar agents de programação com o Haiku. Agora, o Qwen. Ele trabalhou por quase 2 horas e deu 130 passos. E, depois de cerca de uma hora

04:10 e meia, o contexto chegou perto do limite. O agent teve que compactar o histórico de 181.000 tokens para 27.000. Só isso levou cerca de 10 minutos. Mas, no fim, o modelo concluiu o trabalho. Todos os testes existentes passaram. O linter e a verificação de tipos também. O Qwen até escreveu os próprios testes, e eles também passaram. Agora, vamos conferir com meus testes ocultos. Nove de 13. Dois dos erros são relativamente pequenos, mas outro é um bug de verdade. Se

04:41 um documento estiver aberto no editor e contiver um link para o arquivo renomeado, o Qwen não atualiza esse link. O modelo acertou ao não sobrescrever os documentos abertos no disco, preservando assim as alterações não salvas. Mas depois se esqueceu de atualizar os links dentro dos próprios documentos abertos. E o modelo não percebeu esse problema e informou que a tarefa estava concluída. Na minha opinião, isso é muito mais interessante do que um erro comum de compilação. O projeto compila, todos os testes existentes

05:11 passam, mas um dos recursos principais funciona incorretamente. Uma situação bem perigosa. Agora, sobre o custo. Durante a execução, a placa de vídeo consumiu cerca de 400 watts-hora. Pela minha tarifa, isso dá cerca de 15 centavos de eletricidade. Claro, sem contar o custo do hardware. Para comparar, o Haiku custou 1 dólar e 44 centavos. Mas, considerando a diferença de tempo e de qualidade do resultado, para uma tarefa como essa, eu escolheria o modelo na nuvem. E a última tarefa. Esta não é sobre

05:42 programação. Preparei uma pasta com documentos financeiros: extratos bancários, recibos, e-mails do contador e documentos com informações confidenciais. Os modelos precisam reunir as deduções fiscais de 2025 em uma tabela e preparar uma nota para o contador. E aqui também há algumas armadilhas. Por exemplo, o banco classificou a mensalidade da academia como uma despesa de saúde, embora ela não dê direito a dedução fiscal. No recibo da farmácia, só o medicamento com receita pode ser deduzido, não

06:13 a compra inteira. E é preciso garantir que o número completo do seguro social e os números dos cartões bancários não apareçam nos documentos de saída. O Haiku fez isso em um minuto e meio, por menos de 2 centavos. Todas as 32 verificações passaram. Agora, o Qwen: 6 minutos e meio, e também 32 de 32 verificações. Todos os totais foram calculados corretamente. Todas as condições foram cumpridas. Nenhum dado pessoal extra nos arquivos de saída. Então, o resultado é o mesmo, mas

06:43 há um ponto importante aqui. Quando usei o Haiku, enviei todos esses documentos para os servidores da Anthropic; com o Qwen, eles nunca saíram do meu computador. E, na minha opinião, esse é um dos argumentos mais fortes a favor dos modelos locais. Então, o que obtivemos? O Haiku passou em todos os meus testes sem nenhum erro e trabalhou muito mais rápido. As quatro tarefas custaram cerca de 1 dólar e 65 centavos. O Qwen também apresentou bons resultados, especialmente nos dois primeiros testes e com os documentos financeiros.

07:13 Mas, na tarefa difícil, com muitas mudanças no código, ficou visivelmente atrás do Haiku. Então, esta é a conclusão a que cheguei. Se eu precisar fazer mudanças sérias em um projeto grande, por enquanto vou usar modelos na nuvem. Eles são mais rápidos e, no experimento de hoje, o Haiku fez esse tipo de trabalho melhor. Mas, para trabalhar com documentos pessoais e tarefas pequenas com requisitos claros, o Qwen local de 27 bilhões de parâmetros já é mais do que suficiente, especialmente porque os preços da API para tarefas pequenas agora são tão

07:43 baixos que economizar dinheiro, por si só, já não parece um motivo convincente para comprar uma placa de vídeo cara. Mas poder trabalhar com seus dados sem enviá-los para a nuvem é outra história. Então, com certeza vou continuar usando modelos locais, só não para todas as tarefas. Se você se interessa por testes de modelos de IA como este, inscreva-se no canal e na minha newsletter semanal sobre TI e IA. O link está na descrição. Até breve. Se cuidem.

Transcrição original

[00:00] Last week Anthropic released Claude Haiku 5.5. It’s their fastest and cheapest model, just 10 cents per million input tokens. At prices like that, an interesting question comes up. Why run local models on your own computer at all? I decided to find out. I took Haiku 5.5 and a local Qwen 3.8 with 27 billion parameters and gave them the same tasks, from a small Python utility to fixing bugs in my real app and working with personal financial documents. The results turned out to be

[00:32] interesting. On some tasks, Qwen did just as well as Haiku. On others, it took several times longer and missed bugs it didn’t notice itself. Let’s see what happened. For testing, I’m using the Pi Agent. Both models work with the same tools without any extra extensions and at the maximum reasoning level. I wrote the tests in advance. The models can’t see them and I only run them after the model says it’s done. Haiku runs through the Anthropic API. Qwen runs on my desktop with a Radeon Pro with 32 GB

[01:03] of video memory. The model is running in Llama CPP with Q4 quantization. I set the context to 192,000 tokens. So, let’s get started. The first task is to write a Python utility that splits shared expenses between friends and works out who owes whom how much. At first glance, nothing difficult, but I hid 12 traps in the spec. For example, money can’t be stored as floating point numbers. Leftover cents have to be distributed by a specific rule. And at

[01:35] the end of the document, there are changes after review that cancel some of the earlier requirements. Let’s start with Haiku. It finished in 3 and 1/2 minutes and spent less than 4 cents. All 32 checks passed. Now Qwen. It also passed all 32 checks, not a single mistake, although it worked for half an hour, almost nine times longer. So, in terms of quality, the result is the same, but the difference in time is already significant. Now, let’s move on to a real project. I

[02:06] have a desktop markdown editor called Textodus. It has more than 20,000 lines of code, including some in Rust. The first task is to fix the word and character count. Right now, Chinese text is counted as a single word, and some emoji, like a flag or a family, count as several characters. I gave both models the plain text of the issue with no extra explanation. Haiku fixed everything in 8 minutes, cost 16 cents. All 13 hidden tests passed. Qwen also

[02:36] mostly solved the task, but one test failed. It decided to count every Korean syllable as a separate word, even though Korean separates words with spaces. As a result, a two-word phrase turned into seven words. A small mistake, but still a mistake. Now, a harder task. Textodus has a problem. If you rename or move a file, links to it from other notes stop working. I want them to update automatically, kind of like in Obsidian. There are quite a few nuances here.

[03:06] Links inside code blocks must not be touched. If a document is open and has unsaved changes, you can’t just override it on disk. And when a folder is moved, relative links have to be handled correctly. Okay, Haiku first. It worked for 22 minutes and took 81 steps. All 13 of my hidden tests passed, and all 530 existing tests in the project. But, the cost turned out to be surprisingly high, a dollar 44. The thing is, Haiku 5.5 has

[03:38] a threshold of 100,000 tokens per request. If you go over it, the whole request costs five times more. And an agent working on a large project keeps sending the model the whole history of its work. In my case, 58 requests went over that threshold. Without the higher rate, the task would have cost about 32 cents. So, this is worth keeping in mind when you use Haiku encoding agents. Now, Gwen. It worked for almost 2 hours and took 130 steps. And after about an hour

[04:10] and a half, the context got close to the limit. The agent had to compact the history from 181,000 tokens down to 27,000. That alone took about 10 minutes. But in the end, the model finished the job. All the existing tests pass. The linter and the type check, too. Gwen even wrote its own tests, and they pass as well. Now, let’s check it with my hidden tests. Nine out of 13. Two of the mistakes are fairly minor, but another one is a real bug. If

[04:41] a document is open in the editor and contains a link to the renamed file, Gwen doesn’t update that link at all. The model was right not to overwrite open documents on disk, so that unsaved changes are kept. But then it forgot to update the links inside the open documents themselves. And the model didn’t notice this problem itself, and reported that the task was done. In my opinion, this is far more interesting than an ordinary compile error. The project builds, all the existing tests

[05:11] pass, but one of the core features works incorrectly. A pretty dangerous situation. Now, about the cost. During the run, the graphics card used about 400 watt hours. At my rate, that’s about 15 cents of electricity. Of course, not counting the cost of the hardware. For comparison, Haiku cost a dollar 44. But given the difference in time and in the quality of the result, for a task like this, I’d go with the cloud model. And the last task. This one isn’t about

[05:42] programming. I prepared a folder with financial documents, bank statements, receipts, the accountant’s emails, and documents with confidential information. The models have to collect the tax deductions for 2025 into a table and prepare a note for the accountant. And there are a few traps here, too. For example, the bank labeled the gym membership as a health expense, even though there’s no tax deduction for it. On the pharmacy receipt, only the prescription drug can be deducted, not

[06:13] the whole purchase. And have to make sure that the full social security number and bank card numbers don’t end up in the output documents. Haiku did it in a minute and a half, less than 2 cents. All 32 checks passed. Now, Qwen, 6 and 1/2 minutes, and also 32 out of 32 checks. All the totals are calculated correctly. All the conditions are met. No extra personal data in the output files. So, the result is the same, but

[06:43] there’s one important point here. When I used Haiku, I sent all these documents to Anthropic’s servers, and with Qwen, they never left my computer at all. And in my opinion, that’s one of the strongest arguments for local models. So, what did we get? Haiku passed all my tests without a single mistake and worked much faster. All four tasks cost about a dollar 65. Qwen also showed good results, especially in the first two tests and with the financial documents.

[07:13] But on the hard task with lots of code changes, it fell noticeably behind Haiku. So, here’s the conclusion I came to for myself. If I need to make serious changes to a large project, for now, I’ll use cloud models. They’re faster, and in today’s experiment, Haiku did that kind of work better. But for working with personal documents and small tasks with clear requirements, the local 27 billion parameter Qwen is already quite enough, especially since API prices for small tasks are now so

[07:43] low that saving money on its own no longer looks like a convincing reason to buy an expensive graphics card. But being able to work with your data without sending it to the cloud is a completely different matter. So, I’ll definitely keep using local models, just not for every task. If you’re interested in tests of AI models like this, subscribe to the channel and to my weekly newsletter about IT and AI. The link is in the description. See you soon. Take care.