Acredito em tudo que meus agentes me dizem: três níveis de revisão — Corey Gallon, Rexmore

Autoria: AI Engineer · 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: I Believe Everything My Agents Tell Me: Three Levels of Review — Corey Gallon, Rexmore · Canal: AI Engineer · 11:54 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Avaliação e benchmarks de IA

Resumo

Corey Gallon explica um método de revisão em três níveis para detectar exageros, erros factuais e falhas de raciocínio de agentes. O método combina entregáveis verificáveis, conferência independente com fontes e revisões adversariais feitas por avaliadores sem acesso ao contexto original. Exemplos reais mostram o uso das revisões para investigar um vazamento de memória, conferir registros contábeis e avaliar uma carta de cobrança com implicações jurídicas e financeiras. O objetivo é confiar no trabalho dos agentes porque ele foi validado por outros agentes, não porque os agentes estejam sempre certos.

Pontos-chave

Em cerca de quatro de cada dez sessões analisadas, um agente cometeu um erro relevante.
O nível um exige que o agente especifique o artefato esperado e comprove sua entrega, em vez de apenas dizer que terminou.
O nível dois usa agentes que trabalham de forma independente e compara seus resultados com a fonte original.
O nível três inclui uma auditoria das próprias afirmações e revisores adversariais sem acesso ao contexto original.
No caso do vazamento de memória, revisores identificaram um teste incompleto e uma medição que subestimava o problema.
Na conferência contábil, os registros foram comparados com os extratos e equilibrados até o centavo.
Na revisão da carta de cobrança, revisores encontraram uma cláusula de renovação automática que invalidava a premissa do rascunho.
As revisões são realizadas por agentes e, nos exemplos apresentados, levaram de 15 a 20 minutos.
O autor disponibilizou os três níveis de revisão como agent skills open source.

Capítulos

Início	Capítulo	Resumo
00:00	Por que revisar o trabalho dos agentes	O apresentador descreve a frequência dos erros e introduz três níveis de revisão para lidar com falhas de execução, fatos e raciocínio.
03:37	Nível três e vazamento de memória	O método é aplicado a uma investigação de vazamento de memória, na qual revisores detectam erros sobre a causa e a eficácia da correção.
06:43	Revisão de registros contábeis	Agentes extraem transações de extratos digitalizados e comparam os resultados para identificar diferenças e equilibrar o ano.
08:45	Revisão de uma carta com implicações legais	Revisores encontram uma cláusula de renovação automática, levam à reescrita da carta e validam sua versão final antes do envio.

Citações

Acredito em tudo que meus agentes me dizem. E, ainda assim, meus agentes erram o tempo todo. — 00:00

Dizer que terminou, por si só, não é uma resposta aceitável. — 01:32

Nunca força uma concordância. — 02:34

A verificação do próprio agente concordou com o próprio erro. — 10:18

Acredito neles porque tudo em que confio foi revisado e validado cuidadosamente antes. E, o mais importante, não por mim. — 11:54

Conceitos e entidades

Corey Gallon (pessoa): Apresenta o método de revisão de agentes e os exemplos de sua aplicação.
agent skill (conceito): Formato usado pelo autor para empacotar cada nível de revisão como um procedimento que agentes podem seguir.
Level one review (conceito): Nível de revisão que especifica o artefato esperado e exige evidência de que ele foi entregue.
Level two review (conceito): Nível de revisão que compara resultados independentes com uma fonte original para detectar erros factuais.
Level three review (conceito): Nível de revisão adversarial que examina afirmações e submete o trabalho a revisores sem o contexto original.
fan-out, fan-in (conceito): Padrão em que agentes recebem tarefas idênticas em paralelo e seus resultados são depois reunidos e comparados.
AI Engineer (empresa): Canal do YouTube em que a apresentação foi publicada.
gallon.me (ferramenta): Endereço indicado pelo apresentador para acessar o texto sobre o método de revisão.

Tradução completa (pt-BR)

00:00 Acredito em tudo que meus agents me dizem. E, ainda assim, meus agents erram o tempo todo. Neste ano, passei mais de 107 bilhões de tokens por agents. Então, analisei minhas sessões com agents desde o início de 2026 para ver onde eles erraram. Em cerca de quatro a cada 10 sessões, um agent errou em algo que importava. Essa é a frequência com que os agents erram, antes de mais nada. Não é a frequência com que esses erros chegaram aos resultados do trabalho.

00:30 Identificar esses erros antes que cheguem até mim é o trabalho do método de revisão baseado em agents que venho usando durante a maior parte deste ano, e é esse método que vou compartilhar com vocês hoje. Esta análise identificou três maneiras pelas quais os agents continuam falhando. Número um: eles exageram o que fizeram. Isto é, dizem que algo está pronto ou foi verificado quando não está. Número dois: erram os fatos. Por exemplo, interpretam mal a fonte. Ou número três: erram o raciocínio. Ou seja, os fatos estão certos, mas a

01:01 conclusão não. O método é composto por três níveis de revisão, um para cada uma das três maneiras pelas quais os agents continuam falhando. Criei cada nível como uma skill de agent. Veja como cada um funciona e, depois, vou mostrar como cada um foi aplicado em três casos reais. O nível um impede que os agents exagerem o que fizeram. Antes de um agent começar, a tarefa especifica exatamente o que ele precisa entregar.

01:32 O arquivo, onde deve ser colocado e um comando para verificá-lo. Ela aponta os atalhos que os agents já tomaram antes, para que este não os repita. O agent que faz a revisão precisa concluí-la com uma de duas coisas: artefato verificado, com uma impressão digital do arquivo ou dos arquivos que documentam seu trabalho; ou artefato ausente, com a justificativa. Então, o agent que enviou a tarefa executa a verificação por conta própria. Dizer apenas “pronto” não é uma resposta

02:03 aceitável. O nível dois impede que os agents errem os fatos. Quando a precisão importa, primeiro encontre algo na fonte com que a resposta precise estar de acordo. Depois, dois agents recebem um conjunto idêntico de instruções e realizam a mesma tarefa de forma independente. Nenhum deles vê o trabalho do outro. Cada um registra de onde veio cada fato e confere seu resultado com os fatos. Em seguida, um terceiro agent, com a fonte original à sua frente, compara o trabalho

02:34 dos dois agents independentes linha por linha e resolve cada divergência voltando à fonte. Ele nunca força uma correspondência. O nível três impede que os agents errem no raciocínio. Quando a clareza do pensamento realmente importa, fazemos uma revisão adversarial em três etapas. Primeiro, o agent audita o próprio trabalho. Ele lista todas as afirmações que está fazendo e marca cada uma como medida, verificada com a fonte, inferida ou presumida.

03:07 Tudo o que não conseguir sustentar é testado ou identificado como suposição. Segundo, revisores sem nenhum contexto do agent original, cada um atuando como uma persona com motivos para encontrar falhas, leem o material sem conhecimento prévio. Cada um se coloca no lugar de um leitor real e recebe o trabalho e as fontes, mas não o histórico, os rascunhos nem conclusões com as quais concordar. As constatações deles também são conferidas com a fonte antes de qualquer alteração.

03:37 Terceiro, depois que o trabalho é revisado, novos revisores, que nunca o viram, conferem a versão final. Cada nível se soma ao anterior à medida que aumentam os riscos. Nesses casos, cada revisão levou minutos, não horas, e quem faz a verificação são os agents, não eu. Na escala em que operamos, não é possível eu mesmo conferir tudo. Então, vamos ver cada nível de revisão aplicado em três casos reais. Primeiro, um vazamento de memória. Um aplicativo de ditado open source que uso estava

04:07 vazando memória. Seu uso chegou a 9 GB. Nosso objetivo era encontrar o vazamento, corrigi-lo e conseguir que a correção fosse aceita pelo mantenedor do projeto. E, para corrigi-lo, precisávamos descobrir o que realmente o causava. Meus agents e eu investigamos, e três vezes um agent me disse algo que não era verdade. Primeiro, um subagent que enviei para medir o vazamento com uma ferramenta usou outra e informou que havia concluído o trabalho, sem dizer que não tinha usado a ferramenta conforme as instruções.

04:39 Ninguém percebeu isso a princípio, nem mesmo o agent que delegou o trabalho. A falha veio à tona quando questionei os resultados. O arquivo que a ferramenta correta teria produzido não existia, e ninguém havia notado. É para isso que serve o nível um da revisão. Neste caso, enviamos um subagent para criar uma versão especialmente instrumentada do aplicativo e coletar telemetria enquanto ele estava em execução. No entanto, a compilação falhou. Como instruímos o subagent a fornecer a documentação de todo o trabalho, em vez de apenas dizer “pronto”, ele informou que a

05:11 entrega principal não havia sido feita e explicou o motivo. Ele informou que faltava um artefato — a compilação do software — e que havia 25 erros do compilador, e identificou corretamente como parcial aquilo que conseguiu entregar. Enviar o subagent com as instruções da tarefa de revisão de nível um levou 19 minutos e cerca de 16 milhões de tokens. As outras duas imprecisões significativas dos agents estavam prestes a se tornar públicas, e os riscos eram maiores; por isso,

05:41 para elas, recorremos a revisores sem nenhum contexto dos agents, como no nível três. Veremos as três etapas de uma revisão de nível três no último exemplo que vou explicar daqui a pouco, mas foi assim que funcionou para a correção do vazamento de memória. No segundo caso, um agent culpou o código errado. Para encontrar a origem do vazamento, ele escreveu um pequeno teste que usava a mesma biblioteca do aplicativo. O teste também vazava, então concluiu que a culpa era da biblioteca. Ele disse: “Isso é sólido o bastante para abrir um pull request.” Os revisores reproduziram o teste e descobriram

06:12 que ele havia pulado uma etapa importante exigida pela biblioteca. Usada corretamente, a biblioteca não vazava. O problema estava na forma como o aplicativo usava a biblioteca. No terceiro erro significativo dos agents que trabalhavam no vazamento de memória, o agent descreveu nossa correção para o pull request e disse que ela eliminava completamente o vazamento, mas havia medido o vazamento de um jeito que deixava passar a maior parte dele. Os revisores também perceberam isso. A correção reduziu o vazamento, mas não o eliminou por completo. Então, o pull request

06:43 foi enviado com números honestos, e o mantenedor aceitou a correção e a integrou. Cada uma dessas revisões de nível três levou cerca de 15 minutos e, juntas, custaram cerca de 6 milhões de tokens. No próximo exemplo, vamos falar da contabilidade de uma empresa do nosso portfólio. Comprar e construir empresas pode ser complicado. Para uma das empresas do nosso portfólio, precisávamos transformar um ano de extratos digitalizados de um sistema de contabilidade de origem em um registro completo e preciso de todas as transações comerciais, para fins de relatórios financeiros.

07:14 Um agent extraiu os dados do ano e os devolveu dizendo: “Ei, recomendo conferir algumas dessas transações por amostragem.” Isso devolvia para nós o ônus de revisar o trabalho do agent, o que não era aceitável. A extração de dados de digitalizações muitas vezes dá errado de maneiras tediosas e difíceis de detectar. Transações são totalmente omitidas, colocadas nos meses errados ou registradas com detalhes incorretos. Um agent simplesmente dizer que terminou não

07:44 permite saber se alguma dessas coisas aconteceu. E é para isso que serve o nível dois do método de revisão. Aqui, usamos o saldo impresso nos extratos como total de controle de cada mês. Dois agents extraíram os dados de cada mês de forma independente, e cada um voltou aos extratos até que todos os meses fechassem. Depois, um terceiro agent comparou as duas extrações linha por linha e resolveu cada divergência consultando os próprios extratos. Por fim, mais dois agents, com instruções idênticas,

08:15 conferiram cada registro final de transação antes de ele ser aceito. Esse padrão de distribuir tarefas entre vários agents com instruções idênticas e depois reunir os resultados é muito eficaz para aumentar a precisão e a confiabilidade. Quando fizemos essa revisão de nível dois, encontramos transações omitidas, transações incorretas e transações nos meses errados. A comparação das duas extrações encontrou 56 diferenças nas descrições, datas e observações. Mas, no fim, o ano inteiro fechou

08:45 até o último centavo. Toda essa revisão levou cerca de 20 minutos e custou 7,5 milhões de tokens. Por último, o exemplo de maior risco. Mais complicações de negócios de uma empresa do nosso portfólio. Uma das nossas estava em uma disputa de cobrança com um fornecedor, envolvendo milhares de dólares e implicações jurídicas. Precisávamos enviar uma carta de cobrança que declarasse claramente nossa posição e nossas exigências, e todas as afirmações nela precisavam estar respaldadas pelo contrato e por cada fatura.

09:16 Um agent redigiu a carta partindo da premissa de que o contrato do fornecedor havia expirado. Tudo o que envolve riscos jurídicos ou financeiros passa por uma revisão de nível três antes de ser enviado, e foi assim que o nível três foi aplicado a esta carta. Primeiro, a autoauditoria. O agent conferiu as afirmações da carta com o contrato e as faturas, inclusive as datas, e informou que estavam verificadas. A primeira etapa foi aprovada. Segundo, revisores sem conhecimento prévio, cada um em um papel com motivos para encontrar falhas. Então, neste

09:47 Neste caso, nosso próprio advogado litigante, o advogado do fornecedor e um auditor que não confia em nenhum dos números. Cada um recebeu a carta, o contrato e as faturas, e nada mais. O auditor recalculou a cobrança financeira com base nas faturas, e o valor estava correto até o centavo. Mas os dois advogados encontraram, independentemente, algo escondido nas letras miúdas do contrato: uma cláusula de renovação automática por três anos. O contrato havia sido renovado automaticamente menos de três semanas antes.

10:18 As exigências da carta teriam nos levado a abandonar um contrato que ainda estava em vigor e a dever milhares de dólares ao fornecedor por encerrá-lo antecipadamente. Os dois agents advogados também descobriram que, ao revisar o texto, o agent original havia até apagado uma linha que identificava corretamente a renovação. A própria checagem do agent original havia confirmado o próprio erro. Exatamente o tipo de coisa que esse método de revisão foi criado para detectar. O veredito do nosso advogado litigante, porém, foi: não envie a carta. Esse processo de revisão às cegas em três partes levou

10:51 15 minutos e custou 13 milhões de tokens. Então, a carta foi reescrita e encaminhada à terceira etapa da revisão de nível três. Novos revisores, que nunca a tinham visto, conferiram a versão final. A versão com falhas nunca foi enviada. Então, essas são três histórias de revisão e três níveis de revisão. Um agent que não conseguiu criar uma versão personalizada do aplicativo disse isso, em vez de afirmar incorretamente que estava pronto. Dois grupos de dois agents extraíram e contabilizaram um ano de transações comerciais

11:22 até o último centavo. E revisores com personas, sem nenhum contexto do agent original, corrigiram uma carta que a própria checagem dos agents que a redigiram havia considerado verificada. Organizei os três níveis de revisão como skills de agents e os disponibilizei como open source. O texto explicativo está em gallon.me. Peça ao seu agent para consultar o texto explicativo, e ele saberá como conferir o próprio trabalho usando esse método de revisão, para que você possa confiar nele. Para saber mais sobre as melhores maneiras de realizar trabalho de verdade com agents de IA, inscreva-se na

11:54 minha newsletter e conecte-se comigo por aqui. Então, acredito em tudo que meus agents me dizem. Não porque estejam certos. Eles erram o tempo todo. Acredito neles porque tudo em que confio foi primeiro revisado e validado minuciosamente. E, o mais importante, não por mim.

Transcrição original

[00:00] I believe everything my agents tell me. And yet, my agents get things wrong all the time. I’ve put over 107 billion tokens through agents this year. So, I analyzed my agent sessions from 2026 year-to-date to see where they went wrong. In about four in 10 sessions, an agent got something wrong that mattered. That’s how often agents get things wrong in the first place. It isn’t how often those errors made it into work outputs.

[00:30] Catching those errors before they reach me is the job of the agent-based review method that I’ve been running for most of this year, and that’s the method that I’m sharing with you today. This analysis identified three ways agents keep failing. Number one, they overstate what they did. That is, they say it’s done or checked when it isn’t. Number two, they get the facts wrong. They misread the source, for example. Or number three, they get the reasoning wrong. So, the facts are right, but the

[01:01] conclusion isn’t. The method is comprised of three levels of review, one to address each of the three ways that agents keep failing. I built each level as an agent skill. Here’s how each one works, and then I’ll show you how each was applied in three real cases. Level one prevents agents overstating what they did. Before an agent starts, the job spells out exactly what it has to hand back.

[01:32] The file, where it goes, and a command that checks it. It points out the shortcuts agents have taken before, so this one doesn’t repeat them. The agent performing the review has to end its review with one of two things. Artifact verified with a fingerprint of the file or files documenting its work, or artifact missing with the reason. Then, the agent that sent the job runs the check itself. Saying done on its own isn’t a

[02:03] permissible answer. Level two prevents agents from getting the facts wrong. When correctness matters, first find something in the source that the answer has to agree with. Then, two agents get an identical set of instructions and do the same job independently. Neither one sees the other’s work. Each one notes where every fact came from and checks its result against the facts. Then, a third agent with the original source in front of it compares the work

[02:34] of the two independent agents line by line and settles every difference by going back to the source. It never forces a match. Level three prevents agents getting the reasoning wrong. When clarity of thought really matters, we perform adversarial review in three stages. First, the agent audits its own work. It lists every claim it’s making and marks each one as measured, checked against the source, inferred, or assumed.

[03:07] Anything it can’t back up gets tested or labeled as a guess. Second, reviewers with none of the original agent’s context, each acting as a persona with reasons to find fault, read it cold. Each one plays a real reader and gets the work and the sources, but no history, no drafts, and no conclusions to agree with. Their findings get checked against the source, too, before anything changes.

[03:37] Third, once the work is revised, brand new reviewers who’ve never seen it check the final version. Each level adds to the one before as the stakes go up. In these cases, each review took minutes, not hours, and the agents do the checking, not me. At the scale we operate, checking it myself isn’t an option. So, let’s see each review level applied in three real cases. First, a memory leak. An open-source dictation app I use was

[04:07] leaking memory. It grew to 9 GB. We set out to find the leak, fix it, and get the fix accepted by the project’s maintainer. And to fix it, we had to find out what was really causing it. My agents and I went after it, and three times an agent told me something that wasn’t true. First, a sub-agent I sent to measure the leak with one tool used another and reported its work as done without saying it hadn’t used the tool as instructed.

[04:39] Nobody caught it at first, including the agent that dispatched the work. It came out when I questioned the results. The file the right tool would have produced didn’t exist, and nobody had noticed. That’s what level one of the review is for. In this case, we dispatched a sub-agent to build a specially instrumented version of the app and capture telemetry while it was running. However, the build failed. Because we instructed the sub-agent to provide documentation of all of its work, instead of just done, it said the

[05:11] main deliverable wasn’t delivered and explained why. It reported that an artifact was missing, the software build, and that there were 25 compiler [clears throat] errors, and it correctly labeled the what it could deliver as partial. Dispatching the sub-agent with level one review tasking included took 19 minutes and about 16 million tokens. The other two significant inaccuracies by agents were about to go public, and the stakes were higher, so for those

[05:41] we borrowed from level three, reviewers with none of the agents’ context. We’ll see all three stages of a level three review in the last example I explain shortly, but here’s how it worked for the memory leak fix. In the second case, an agent blamed the wrong code. To find the leak source, it wrote a small test that used the same library the app does. The test leaked, too, so it concluded that the library was to blame. It said, “This is solid enough to file.” Reviewers reproduced the test and found

[06:12] that it had skipped an important step that the library requires. Used properly, the library didn’t leak. The problem was in how the app used the library. In the third significant error by agents working on the memory leak, the agent wrote up our fix for the pull request and said that it eliminated the leak completely, but it had measured the leak in a way that missed most of it. Reviewers caught that, also. The fix reduced the leak, but it didn’t fully eliminate it. So, the pull request

[06:43] went up with honest numbers, and the maintainer accepted the fix and merged it. Each of these level three reviews took about 15 minutes and, together, cost about 6 million tokens. For the next example, we’ll look at portfolio company accounting. Buying and building businesses can be messy. For one of our portfolio companies, we needed a year of scanned statements from a source accounting system turned into a complete, accurate record of every business transaction for financial reporting purposes.

[07:14] An agent extracted the year and handed it back with, “Hey, I recommend spot-checking a few of these transactions.” This put the burden of reviewing the agent’s work back on us, which is a non-starter. Extracting data from scans often goes wrong in ways that are tedious and difficult to detect. Transactions are missed entirely, transactions are put in the wrong months, or they’re recorded with the wrong details. One agent simply reporting done can’t

[07:44] tell you whether any of that’s happened. And that’s what level two of the review method is for. Here, we use the balance printed on the statements as the control total for each month. Two agents extracted every month independently, and each one went back to the statements until every month balanced. Then, a third agent compared the two extractions line by line and settled each difference against the statements themselves. Finally, two more agents, tasked

[08:15] identically, checked each of the final transaction records before they were accepted. This fan-out, fan-in pattern of identically tasked agents is highly effective in driving accuracy and reliability. When we ran this level two review, we caught missed transactions, incorrect transactions, and transactions in the wrong months. Comparing the two extractions caught 56 differences in descriptions, dates, and notes. But, ultimately, the whole year balanced

[08:45] to the penny. This entire review took about 20 minutes and cost 7.5 million tokens. Last, the highest-stakes example. More messy portfolio company business here. One of ours was in a billing dispute with a vendor, and this amounted to thousands of dollars with legal implications. We needed to send a demand letter clearly stating our position and requirements, and every claim in it had to stand up against the contract and each invoice.

[09:16] An agent drafted the letter on the premise that the vendor’s contract had expired. Anything with legal or financial stakes gets a level three review before it goes out, and here’s how level three ran on this letter. First, the self-audit. The agent checked the claims in the letter against the contract and the invoices, including the dates, and reported them verified. Stage one passed. Second, cold reviewers, each in a role with a reason to find fault, so in this

[09:47] case our own litigator, the vendor’s counsel, and an auditor who trusts none of the numbers. They each got the letter, the contract, and the invoices, and nothing else. The auditor recomputed the financial demand from the invoices, and it was correct down to the cent. But both lawyers independently found something buried deep in the contract’s fine print. A three-year auto-renewal clause. The contract had auto-renewed less than three weeks earlier.

[10:18] The letter’s demands would have had us walking away from a contract that was still in force and owing the vendor thousands of dollars for leaving early. The two lawyer agents also learned that, while revising, the original agent had even deleted a line that had the renewal correctly identified. The original agent’s own check had agreed with its own error. Just the sort of thing this review method is designed to catch. Our litigator’s verdict, though, was do not send the letter. That three-part cold review process took

[10:51] 15 minutes and cost 13 million tokens. So, the letter was rewritten and handed to the third stage of level three review. Brand new reviewers who’d never seen it checked the final version. The flawed version never went out. So, that’s three review stories and three levels of review. An agent that couldn’t build a customized version of the app said so instead of incorrectly saying that it was done. Two groups of two agents extracted and accounted for a year of business

[11:22] transactions down to the penny. And cold persona-based reviewers with none of the original agent’s context revised a letter that the drafting agents’ own check had called verified. I’ve packaged the three review levels as agent skills, and I’ve released them as open source. The write-up is at gallon.me. Point your agent at the write-up, and it will know how to check its own work using this review method, so you can rely on it. To learn more of the best ways to do real work with AI agents, subscribe to

[11:54] my newsletter and connect with me here. So, I believe everything my agents tell me. Not because they’re right. They get things wrong all the time. I believe them because everything I rely on has been thoroughly reviewed and validated first. And most importantly, not by me.