A mesma IA local, dois agentes — só um detectou os próprios erros

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: Same Local AI, Two Agents — Only One Caught Its Own Mistakes · Canal: Zero to MVP · 08:37 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Avaliação e benchmarks de IA, Modelos locais e open source, Privacidade e proteção de dados

Resumo

O vídeo compara o mesmo modelo local, Qwen 3.8 com 27 bilhões de parâmetros, executado em Pilot Deck e Pi em nove tarefas de análise de dados e criação de arquivos. Pilot Deck não errou nenhuma vez, enquanto Pi produziu resultados incorretos em duas execuções e afirmou que estavam corretos. A diferença principal foi a forma de verificar os resultados: Pilot Deck comparou cálculos independentes e corrigiu inconsistências. Essa maior confiabilidade exigiu mais tempo e energia; o autor ressalva que o teste é pequeno e não permite concluir que o resultado sempre se repetirá.

Pontos-chave

O experimento manteve o modelo, o computador e as tarefas iguais, variando apenas o agente.
As tarefas usaram dados fictícios de pagamentos e assinaturas, com regras e casos deliberadamente enganosos.
Pilot Deck concluiu nove execuções sem erros; Pi teve erros em duas das nove execuções.
Ao calcular métricas, Pilot Deck comparou a planilha com um cálculo independente em Python, identificou uma fórmula incorreta e a corrigiu.
Em uma execução, Pi aplicou a conversão de euros a pagamentos em dólares e, em outra, não excluiu contas de teste.
As verificações independentes de Pilot Deck não dependeram de suas skills de Excel e PowerPoint: o agente também passou nos testes sem elas.
Pilot Deck demorou 2 horas e 8 minutos para as nove tarefas, contra menos de uma hora de Pi, e a placa de vídeo consumiu mais que o dobro de energia.
O autor conclui que um agente mais robusto pode tornar um modelo local mais confiável, embora seja mais lento e o teste não prove que isso ocorrerá sempre.

Capítulos

Início	Capítulo	Resumo
00:00	O experimento e os agentes	O autor apresenta a comparação entre Pilot Deck e Pi com o mesmo modelo local e explica como o agente de escritório cria arquivos.
02:08	Dados e tarefas do teste	O teste usa dados fictícios de pagamentos e assinaturas, com armadilhas, para avaliar tarefas em três níveis de dificuldade.
03:47	Verificação de métricas e erros	Pilot Deck encontra e corrige uma fórmula errada ao comparar cálculos independentes, enquanto Pi deixa passar um erro de conversão.
05:57	O que explica a diferença	O autor descobre que as verificações independentes do agente, e não as skills especializadas, explicam os resultados do teste.
07:34	Custo e conclusão	Pilot Deck foi mais lento e consumiu mais energia, mas não errou nas nove execuções; o autor ressalva que a amostra é limitada.

Citações

Espere, cometi um erro. — 03:47

O modelo encontrou o erro, corrigiu a fórmula e depois conferiu os clientes de uma terceira maneira. — 04:19

Salve o script em um arquivo, execute-o, veja o resultado e corrija. — 06:30

No meu teste, sim. — 08:06

Conceitos e entidades

Pilot Deck (ferramenta): Agente de IA open source para tarefas de escritório que cria e verifica arquivos como planilhas e apresentações.
Pi (ferramenta): Agente simples usado como comparação com Pilot Deck nas mesmas tarefas.
Qwen3.8 (modelo): Modelo local com 27 bilhões de parâmetros usado nos testes.
llama.cpp (ferramenta): Ferramenta usada para executar o modelo localmente no computador do autor.
LibreOffice (ferramenta): Suíte de escritório instalada para recalcular e verificar planilhas e apresentações.
Stripe (empresa): Serviço cujas exportações fictícias de pagamentos foram usadas como dados do experimento.
Verificação independente (conceito): Método de conferir um resultado comparando a planilha com um cálculo separado, por exemplo, feito em Python.
skills de Excel e PowerPoint (conceito): Instruções especializadas do Pilot Deck para criar e verificar planilhas e apresentações.

Tradução completa (pt-BR)

00:00 Em um vídeo recente, dei algumas tarefas reais para um Qwen 3.8 com 27 bilhões de parâmetros. Ele lidou muito bem com algumas delas, mas cometeu erros em outras e nem percebeu. Hoje, quis testar uma ideia diferente. E se não fosse só uma questão do modelo, mas também do agent em que ele é executado? Então, usei o mesmo modelo, o mesmo computador, as mesmas tarefas, mas dois agents diferentes, e fiz mais um experimento. E os resultados me surpreenderam. Em um agent,

00:32 o modelo não cometeu um único erro em nove execuções. No outro, produziu um resultado errado duas vezes e afirmou com confiança que tudo estava correto. Mas o motivo acabou sendo completamente diferente do que eu esperava. Para os experimentos de hoje, estou usando o Pilot Deck. É um agent de IA open source para trabalho de escritório. Está disponível no GitHub, então você também pode experimentar. A ideia principal por trás desse agent é simples. Você descreve uma tarefa em linguagem natural, e o agent planeja as etapas, trabalha com seus arquivos e entrega documentos prontos para você,

01:03 como planilhas do Excel, apresentações do PowerPoint e documentos do Word — não texto em um chat, mas arquivos que você pode abrir e editar. É um agent de uso geral, e você pode conectá-lo a qualquer modelo, inclusive um local. Instalar o Pilot Deck exige apenas um comando, mas há um detalhe importante. Se você precisa trabalhar com planilhas e apresentações, como eu faço no experimento de hoje, também precisa instalar o LibreOffice separadamente. Sem ele, o agent consegue criar arquivos, mas não consegue verificá-los. Para o modelo, estou usando o Qwen 3.8 com

01:37 27 bilhões de parâmetros. Estou executando-o com o llama.cpp no meu computador de mesa, com uma Radeon Pro com 32 GB de memória. A única diferença em relação ao meu último teste é o nível de raciocínio. Da última vez, estava no máximo. Desta vez, escolhi o nível médio. Segundo relatos, esse modelo fica instável no nível máximo. Conecto o modelo ao agent como um servidor compatível com OpenAI, e pronto. A propósito, a telemetria anônima no Pilot Deck fica desativada por padrão. Então, depois da

02:08 instalação, o agent não envia nada a lugar nenhum sem a sua permissão. Certo, vamos à tarefa de hoje. Inventei uma pequena empresa SaaS e preparei exportações do Stripe para oito meses: quase 800 pagamentos e quase 300 assinaturas. O trabalho é preparar um relatório mensal para um investidor, uma pasta de trabalho do Excel com métricas e uma apresentação curta. Os dados são inventados, mas são exatamente o tipo de coisa que você não quer muito enviar para a nuvem. Receita, clientes, endereços de e-mail deles. Dividi o trabalho em três

02:41 níveis: uma tabela simples, métricas calculadas de acordo com as regras e um pacote completo para investidores. E, claro, os dados têm pegadinhas: contas de teste, pagamentos em euros, clientes que clicaram em cancelar, mas continuam pagando. Tudo isso está descrito nas regras. O agent só precisa segui-las com atenção. O verificador fica oculto. Eu o executo depois que o agent termina. Executo cada tarefa três vezes no Pilot Deck e três vezes no Pi, o agent simples do meu último vídeo. Então, a primeira tarefa. É simples: criar uma tabela da receita por mês com base na exportação de pagamentos,

03:16 O modelo acertou nas duas opções de agent em todas as três execuções. Nenhum erro. Mas, no Pilot Deck, a tarefa levou de 7 a 9 minutos. No Pi, de 2 a 4. Por que tamanha diferença? O Pilot Deck fornece muito mais contexto ao modelo: instruções, descrições de ferramentas e skills. O modelo dá mais passos e faz mais verificações. Como resultado, foram usados dez vezes mais tokens em uma tarefa simples. Portanto, numa tarefa simples, o Pilot Deck ainda não acrescentou nada. A segunda tarefa

03:47 é mais difícil. Calcular MRR, churn, novos clientes e receita seguindo as regras à risca. E foi aí que aconteceu, provavelmente, o momento mais interessante de todo o teste. O Pilot Deck criou a pasta de trabalho, depois a recalculou no LibreOffice e comparou os resultados com um cálculo separado feito em Python. Os números não batiam. E [limpa a garganta] aqui está o que o modelo escreveu no raciocínio: “A coluna H é o preço mensal na moeda local. Espera, cometi um erro. A fórmula do MRR estava usando o preço na moeda da assinatura

04:19 em vez de em dólares.” O modelo encontrou o erro, corrigiu a fórmula e, depois, conferiu os clientes de uma terceira maneira. No fim, as três execuções não tiveram um único erro. Agora, o mesmo modelo no Pi. Na primeira execução, a taxa de câmbio do euro foi aplicada a todos os pagamentos, inclusive aos que eram em dólares. US$ 9 viraram US$ 9,72. E, na resposta, o modelo afirma com confiança: “Euros convertidos pela taxa do mês.” Exatamente o mesmo erro que o Pilot Deck cometeu. Só que, nesse caso, o

04:49 modelo percebeu porque verificou o resultado. Aqui, não percebeu. A terceira tarefa é a mais difícil. Uma pasta de trabalho mais uma apresentação de até seis slides. As principais métricas de agosto com a variação em relação a julho, um gráfico de MRR, os motivos pelos quais os clientes cancelaram e os planos para o próximo mês. Aqui está o que o Pilot Deck produziu. Slides limpos, com gráficos adequados. Todos os números correspondem aos da pasta de trabalho. E, o mais importante, o modelo identificou corretamente o principal motivo dos cancelamentos: o preço. E quase metade das reclamações sobre preço não estava em

05:22 um campo específico, apenas em comentários de texto livre. Antes de entregar os arquivos, o agent verificou por conta própria que eles não continham endereços de e-mail de clientes, renderizou a apresentação e conferiu se nenhum texto ultrapassava as bordas dos slides. Três execuções em três. Todas as 30 verificações foram aprovadas. No Pi, a primeira execução fez 23 de 30 pontos. O modelo não excluiu as contas de teste. Por causa disso, havia dois clientes a mais e US$ 58 a mais em cada mês. E a resposta dizia: “Contas de teste excluídas em todos os lugares.” As duas execuções seguintes no Pi não tiveram erros. A propósito, dois comentários nos dados são realmente discutíveis. “Alternativas mais baratas já atendem às nossas necessidades.” Isso é sobre o preço ou sobre mudar para outra ferramenta? Então, contei de 11 a 13 cancelamentos relacionados ao preço. Agora, a parte mais interessante: o Pilot Deck tem skills específicas para Excel e PowerPoint, com instruções sobre como criar e verificar arquivos. Eu tinha certeza de que esse era o motivo, mas, quando analisei os registros, descobri que, nos dois primeiros níveis, o Qwen nunca abriu as skills. Nem na primeira execução do terceiro nível. E, mesmo assim, fez 30 de 30 pontos. Criou suas próprias verificações e escreveu todas elas por conta própria. Então, fiz mais um teste. Removi completamente as skills do Pilot Deck e repeti as duas tarefas mais difíceis. O resultado foi o mesmo. Todas as verificações foram aprovadas. Só levou mais tempo. E, como se revelou, o que mais importou no meu teste não foram as skills, mas o próprio agent. As instruções dele contêm uma regra simples: “Salve o script em um arquivo, execute-o, examine a saída e corrija o que for preciso.” E o modelo realmente faz isso. Calcula a mesma coisa de duas maneiras diferentes e compara os resultados. Se não correspondem, vai procurar o erro. No Pi, o modelo também verifica o próprio trabalho, mas de outra forma. Abre o arquivo final e confere se as fórmulas são calculadas e se não há e-mails de clientes nele. O que não lhe ocorre é verificar os números em relação aos dados de origem usando um cálculo independente. Por isso, um erro na própria lógica passa despercebido. Mas essa confiabilidade tem

05:57 um custo. Ao longo das nove tarefas, o Pilot Deck levou 2 horas e 8 minutos. O Pi levou menos de uma hora. E a placa de vídeo consumiu mais que o dobro de energia. E há algumas coisas que vale a pena saber. A busca na web no Pilot Deck só funciona por meio de serviços na nuvem. Totalmente local significa trabalhar apenas com arquivos. E, claro, foram nove rodadas e estas são as estatísticas finais. O modelo no Pi errou duas vezes em nove. É uma diferença real, mas ainda é cedo para dizer que será sempre assim.

06:30 Então, um agent pode tornar um modelo local pequeno mais confiável? No meu teste, sim. O mesmo Qwen no Pilot Deck não cometeu um único erro em nove rodadas. E o que fez a diferença foi o agent com seu system prompt. Então, esta é a minha conclusão. Se a tarefa é simples ou você precisa de uma resposta rápida, um agent leve é suficiente. Mas, se um erro em um relatório custaria caro e você não quer enviar seus dados para a nuvem, um modelo local no Pilot Deck é uma opção perfeitamente viável. Você só precisa esperar um

07:01 pouco mais. Os links para o site do Pilot Deck e o repo no GitHub estão na descrição. Experimente conectar seu próprio modelo e veja como ele lida com as suas tarefas. E, se você gosta de testes de modelos de IA em situações reais como este, inscreva-se no canal e na minha newsletter semanal. Até breve. Se cuidem.

07:34 a um custo. Nas nove tarefas, no total, o Pilot Deck levou 2 horas e 8 minutos. O Pi, menos de uma hora. E a placa de vídeo usou mais que o dobro de energia. E há algumas coisas que vale a pena saber. A busca na web no Pilot Deck só funciona por meio de serviços na nuvem. Totalmente local significa trabalhar apenas com arquivos. E, claro, nove rodadas e as estatísticas finais. O modelo no Pi cometeu dois erros em nove rodadas. É uma diferença real, mas ainda é cedo demais para dizer que vai ser sempre assim

08:06 Então, um agent consegue tornar um modelo local pequeno mais confiável? No meu teste, sim. O mesmo Qwen no Pilot Deck não cometeu um único erro em nove rodadas. E foi o agent, com seu system prompt, que fez a diferença. Então, aqui vai minha conclusão. Se a tarefa for simples ou você precisar de uma resposta rápida, um agent leve é suficiente. Mas, se um erro em um relatório tiver um custo para você e você não quiser enviar seus dados para a nuvem, um modelo local no Pilot Deck é uma opção perfeitamente viável. Você só precisa esperar um

08:37 pouco mais. Os links para o site do Pilot Deck e o repo no GitHub estão na descrição. Experimente conectar seu próprio modelo a ele e veja como ele lida com suas tarefas. E, se você curte testes de modelos de IA no mundo real como este, inscreva-se no canal e na minha newsletter semanal. Até breve. Se cuidem.

Transcrição original

[00:00] In a recent video, I gave a local Quen 3.8 with 27 billion parameters a few real tasks. It handled some of them really well, but on others it made mistakes and didn’t even notice. Today, I wanted to test a different idea. What if it’s not just about the model, but also about the agent it runs in? So, I took the same model, the same computer, the same tasks, just two different agents and run one more experiment. And the results surprised me. In one agent,

[00:32] the model didn’t make a single mistake in nine runs. In the other, it produced a wrong result twice and confidently reported that everything was correct. But the reason turned out to be completely different from what I expected. For today’s experiments, I’m using Pilot Deck. It’s an open-source AI agent for office work. It’s available on GitHub, so you can experiment with it, too. The main idea behind this agent is simple. You describe a task in plain language and the agent plans the steps, works with your files, and hands you

[01:03] finished documents, Excel, PowerPoint, Word, not text in a chat, but files you can open and edit. It’s a general-purpose agent and you can connect any model to it, including a local one. Installing Pilot Deck takes just one command, but there’s one important thing. If you need to work with spreadsheets and presentations, like I do in today’s experiment, you also have to install LibreOffice separately. Without it, the agent can create files, but it can’t check them. For the model, I’m using Quen 3.8 with

[01:37] 27 billion parameters. I’m running it with llama.cpp on my desktop with a Radeon Pro with 32 GB of memory. The only difference from my last test is the reasoning level. Last time, it was set to the maximum. This time, I chose medium. At the maximum level, this model is reportedly unstable. I connect the model to the agent as a regular OpenAI compatible server, and that’s it. By the way, anonymous telemetry in Pilot Deck is off by default. So, after

[02:08] installation, the agent doesn’t send anything anywhere without your permission. Okay, onto today’s task. I made up a small SaaS and prepared Stripe exports for it covering eight months, almost 800 payments, and almost 300 subscriptions. The job is a monthly report for an investor, an Excel workbook with metrics and a short presentation. The data is made up, but it’s exactly the kind of thing you don’t really want to upload to the cloud. Revenue, customers, their email addresses. I split the work into three

[02:41] levels, a simple table, metrics by the rules, and a full investor package. And of course, the data has traps, test accounts, payments in euros, customers who click at cancel, but are still paying. All of this is described in the rules. The agent just has to follow them carefully. The checker is hidden. I run it after the agent is done. I run each task three times in Pilot Deck and three times in Pi, the simple agent from my last video. So, the first task. It’s a simple one. Build a table of revenue by month from

[03:16] the payments export. The model got it right in both agents in all three runs. Not a single mistake. But in Pilot Deck, the task took 7 to 9 minutes. In Pi, 2 to 4. Why such a difference? Pilot Deck gives the model a lot more context, instructions, descriptions of tools and skills. The model takes more steps and checks more. As a result, 10 times more tokens went through it for one simple task. So, on a simple task, Pilot Deck didn’t add anything yet. The second task

[03:47] is harder. Calculate MRR, churn, new customers, and revenue strictly by the rules. And this is where probably the most interesting moment of the whole test happened. Pilot Deck built the workbook, then recalculated it in LibreOffice, and compared it with its own separate calculation in Python. The numbers didn’t match. And [clears throat] here’s what the model wrote in its reasoning. Column H is monthly price local. Wait, I made a mistake. The MRR formula was taking the price in the subscriptions currency

[04:19] instead of in dollars. The model found the mistake, fixed the formula, and then double-checked the customers a third way. In the end, all three runs without a single mistake. Now, the same model in Pi. First run, the euro exchange rate was applied to every payment, including the ones in dollars. $9 turned into 9.72. And in its answer, the model confidently says, “Euros converted at the month’s rate.” Exactly the same mistake Pilot Deck made. Only there, the

[04:49] model caught it because it checked the result. Here, it didn’t. The third task is the hardest. It’s a workbook plus a presentation of up to six slides. August’s key metrics with the change from July, an MRR chart, the reasons customers canceled, and plans for next month. Here’s what Pilot Deck produced. Clean slides with proper charts. All the numbers match the workbook. And most importantly, the model correctly found the main reason for cancellations, price. And almost half of the price complaints weren’t in

[05:22] a dedicated field, only in free text comments. Before handing over the files, the agent checked on its own that they contained no customer email addresses, rendered the presentation, and made sure no text run off the edges of the slides. Three runs out of three. All 30 checks passed. In Pi, the first run scored 23 out of 30. The model didn’t exclude the test accounts. Because of that, every month had two extra customers and 58 extra dollars. And the answer said, “Test accounts excluded everywhere.” The next two runs in Pi had no mistakes. By

[05:57] the way, two comments in the data really are debatable. “Cheaper alternatives do enough for us.” Is that about price or about switching to another tool? So, I counted anywhere from 11 to 13 cancellations as price-related. Now, for the most interesting part, Pilot Deck has special skills for Excel and PowerPoint with instructions on how to create files and how to check them. I was sure that was the reason, but when I went through the logs, it turned out that on the first two levels, Gwen never opened the skills. Not in the first run

[06:30] of the third level, either. And it still scored 30 out of 30. It came up with its checks and wrote them all by itself. So, I run one more test. I removed the skills from Pilot Deck completely and repeated the two hardest tasks. Same result. All checks passed. It just took longer. And as it turned out, what mattered most in my test wasn’t the skills, but the agent itself. Its instructions contain a simple rule, “Save the script to a file, run it, look

[07:01] at the output, and fix it.” And the model really does that. It calculates the same thing two different ways and compares. If they don’t match, it goes looking for the mistake. In Pi, the model checks its work, too, but differently. It opens the finished file and makes sure the formulas calculate and there are no customer emails in it. What never occurs to it is to verify the numbers against the source data with an independent calculation. That’s why a mistake in the logic itself goes unnoticed. But, this reliability comes

[07:34] at a price. Across all nine tasks, Pilot Deck took 2 hours and 8 minutes. Pi, under an hour. And the graphics card used more than twice as much energy. And a few things worth knowing. Web search in Pilot Deck only works through cloud services. Fully local means working with files only. And of course, nine rounds and final statistics. The model in Pi made a mistake two times out of nine. It’s a real difference, but it’s still too early to say it’ll always be like

[08:06] that. So, can an agent make a small local model more reliable? In my test, yes. The same Qwen in Pilot Deck didn’t make a single mistake in nine rounds. And it was the agent with its system prompt that made the difference. So, here’s my conclusion. If the task is simple or you need a quick answer, a lightweight agent is enough. But if a mistake in a report would cost you, and you don’t want to send your data to the cloud, a local model in Pilot Deck is a perfectly workable option. You just have to wait a

[08:37] little longer. Links to the Pilot Deck website and the GitHub repo are in the description. Try connecting your own model to it and see how it handles your tasks. And if you’re into real-world tests of AI models like this one, subscribe to the channel and to my weekly newsletter. See you soon. Take care.