Este agent de 8B corrige os próprios erros? Eu testei

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: This 8B Agent Fixes Its Own Mistakes? I Tested It · Canal: Prompt Engineer 48 · 06:21 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Modelos locais e open source

Resumo

O vídeo testa o Agent Reflex 8B, um modelo treinado para se recuperar de falhas em ferramentas, comparando-o com o Qwen-38B em tarefas locais. Em 120 episódios, os dois modelos tiveram resultados iguais na maioria dos cenários, mas o Agent Reflex se saiu melhor quando recebeu uma resposta JSON truncada. Testes adicionais também mostraram vantagem em respostas vazias, embora ambos os modelos tenham inventado informações em alguns casos. O apresentador ressalta que o experimento é pequeno e não substitui os benchmarks do artigo.

Pontos-chave

O Agent Reflex 8B foi treinado com exemplos de falhas e recuperação, incluindo 1.170 reflection skills.
A receita de treinamento descrita no repo inclui supervised fine-tuning e uma etapa de preferência chamada ORPO.
Nos benchmarks citados, a pontuação média do Qwen-38B passou de 40,2 para 58,6 com o Agent Reflex, mas os ganhos variaram entre tarefas.
O teste local comparou quantizações de 4 bits em uma GPU RTX 4060 de laptop com 8 GB de VRAM.
Nos cenários de timeout, erro de permissão e falha explícita, os dois modelos obtiveram 10 de 10.
Com JSON truncado, o Qwen-38B obteve 1 de 10 e o Agent Reflex, 8 de 10; em testes adicionais, os resultados foram 4 de 20 e 18 de 20.
Em respostas vazias, o Qwen-38B obteve 0 de 20 e o Agent Reflex, 8 de 20, mas ambos ainda inventaram informações em algumas respostas.
O apresentador recomenda interpretar os resultados como um teste exploratório, não como uma conclusão sobre os benchmarks do artigo.

Capítulos

Início	Capítulo	Resumo
00:01	Apresentação do modelo e do método	O apresentador introduz o Agent Reflex 8B, sua proposta de recuperação de falhas e o treinamento baseado em trajetórias e ORPO.
02:06	Configuração e cenários do teste local	O vídeo descreve as quantizações, a tarefa de consulta de pedidos e os seis tipos de falha testados.
03:10	Resultados da comparação	Os modelos empatam em quase todos os cenários, enquanto o Agent Reflex se destaca diante de respostas JSON truncadas.
05:17	Limitações e recomendações	O apresentador mostra exemplos de informações inventadas, ressalva os limites do teste e sugere experimentar o modelo com ferramentas próprias.

Citações

Eu não acreditava que isso apareceria no meu laptop. — 00:01

O modelo original já sabe tentar de novo após um timeout e trocar de ferramenta diante de um erro 403. — 03:42

Este é o único ponto do meu teste em que o treinamento de recuperação aparece claramente. — 04:13

Considere isso um bom começo, não um veredito. — 05:49

Vale a pena testar este Q4 nas suas próprias ferramentas. — 06:21

Conceitos e entidades

Agent Reflex 8B (modelo): Modelo de 8 bilhões de parâmetros testado no vídeo, treinado para lidar com falhas e se recuperar de erros no uso de ferramentas.
Qwen 38B (modelo): Modelo usado como referência na comparação local e nos resultados de benchmark apresentados.
ORPO (conceito): Método de preferência listado na receita de treinamento do repo do Agent Reflex.
reflection skills (conceito): Exemplos de reflexão e recuperação derivados de falhas, usados no treinamento do Agent Reflex.
Hugging Face (empresa): Plataforma onde o vídeo identifica a página do Agent Reflex 8B.
RUC NLPIR (empresa): Grupo associado ao repo do modelo, conforme mencionado no vídeo.
vLLM (ferramenta): Ferramenta usada pelos autores na configuração de seus benchmarks, segundo o apresentador.
RTX 4060 (ferramenta): GPU de laptop com 8 GB usada para executar os testes locais.
Agent Noise Bench (conceito): Benchmark citado no vídeo que injeta falhas para avaliar o uso de ferramentas.

Tradução completa (pt-BR)

00:01 Este artigo diz que um modelo de 8 bilhões de parâmetros saltou de 40,2 para 58,6 em benchmarks de uso de ferramentas só por aprender a se recuperar de erros. Eu não acreditava que isso apareceria no meu laptop, então quebrei as ferramentas de propósito de seis maneiras diferentes, com 10 execuções cada. Em cinco das seis, não fez diferença nenhuma. Em uma delas, o modelo original acertou uma de 10, e este acertou oito. E fique até o fim, porque uma das respostas erradas dele inventou um número. Certo, este é o Agent Reflex 8B no Hugging Face, e você pode ver que diz

00:32 modelo base Qwen-38B, licença MIT, no repo do GitHub do grupo RUC NLPIR. Tem cerca de 75 estrelas, então é um lançamento bem recente. O artigo foi publicado em 13 de outubro, e os pesos foram atualizados no dia seguinte. A ideia é simples. A maioria dos agents é treinada com ferramentas que sempre funcionam. Na vida real, uma ferramenta atinge o tempo limite, retorna uma resposta pela metade ou o usuário diz: “Espere, eu quis dizer outra coisa.” Então, os autores pegam falhas como essas e as transformam em 1.170 skills de reflexão

01:04 e treinam em duas etapas. Primeiro, supervised fine-tuning com cerca de 54.000 trajetórias; depois, uma etapa de preferência que eles chamam de ORPO. Alguns resumos chamam essa segunda etapa de aprendizado por reforço, mas a receita de treinamento do próprio repo lista ORPO, então vou usar esse termo. Agora, vamos olhar os números no próprio repo. Nos cinco benchmarks de uso de ferramentas com horizonte longo, o Qwen-38B marca 40,2 e o Agent Reflex marca 58,6, uma diferença de 18,4 pontos. Mas, se você olhar aqui, a maior parte disso vem

01:35 de uma coluna. O Tau Square Bench vai de 26,2 para 62,1. O A’s Bench vai de 54 para 78. E o Vita Bench, o mais difícil, só vai de 11,4 para 17,5. No Agent Noise Bench, que injeta falhas de propósito, vai de 12,3 para 29,1. Então, a média esconde que o ganho é desigual. Estes são os números dos autores na configuração deles, com vllm, não na minha. Então, aqui está o que estou usando. Esta é a GPU de laptop RTX 4060, com 8 GB de

02:06 VRAM, e tudo aqui é local. Os autores não publicam GGUFs, então estou usando a quantização da comunidade feita por Reader Marker, a Q4KM, que ocupa 5 GB. Ao lado, a quantização original do 38B, da Olamau, também de 4 bits e também com 5,2 GB. As mesmas configurações para ambos: temperatura de 0,6, contexto de 8k. A tarefa é pequena de propósito. O agent é um bot de suporte com uma ferramenta de consulta de pedidos e uma ferramenta reserva, e o usuário pergunta o status e o total do pedido 4821. A resposta certa é enviado

02:37 e 6340, e avaliei a conclusão da tarefa, não o quão agradável soa a explicação. Se o status ou o total estiver errado, é uma falha. Aqui estão os seis cenários. Um: normal, a ferramenta simplesmente funciona. Dois: tempo limite; a primeira chamada retorna um erro de tempo limite, a segunda funciona. Três: malformado; a primeira chamada retorna este JSON que para no meio da palavra “ship”. Quatro: permissão; a ferramenta principal retorna 403 três vezes, então a única saída é a ferramenta reserva. Cinco: sempre indisponível; as duas ferramentas retornam 503 para sempre, então o correto

03:10 é dizer que não consegui obter a informação. Seis: correção do usuário; ele responde e depois eu digo: “Desculpe, eu quis dizer o pedido 4812.” Foram 10 execuções de cada cenário para cada modelo. Isso dá 120 episódios. Vamos assistir a um. Este é o caso de permissão. Você pode ver que ele chama a consulta de pedidos, recebe o 403 e, na segunda chamada, muda para a ferramenta reserva e obtém a resposta. E, se você olhar à direita, a quantização do 38B faz exatamente a mesma coisa. Isso foi o que eu não esperava. O modelo original já sabe tentar de novo quando há um tempo limite e

03:42 mudar de ferramenta diante de um 403. Cada execução leva cerca de 11 segundos nesta placa. Aqui estão os resultados. Normal: 10 de 10 para ambos. Tempo limite: 10 de 10 para ambos. Permissão: 10 para ambos. Sempre indisponível: 10 para ambos. E vale lembrar que só verifiquei se ele não inventava detalhes do pedido. Correção do usuário: 10 para ambos. E, no caso malformado, o Qwen-38B acertou uma de 10. O Agent Reflex acertou oito de 10. No total, foram 58 de 60 contra 51 de 60.

04:13 Agora, veja o que o Qwen-38B faz com um JSON cortado. Ele lê “shipped” como “shipped”, diz que o status é “shipped” e simplesmente para depois de uma chamada. Não tenta de novo. O Agent Reflex fez, em média, 1,8 chamadas nesse cenário, então tenta novamente na maioria das vezes. Este é o único caso do meu teste em que o treinamento de recuperação aparece claramente. Agora, os dois erros. Em um deles, o Agent Reflex disse que o status era “shipped” e que o total era 8919. Esse número não aparece em nenhuma resposta da ferramenta. Ele inventou. Dez execuções é uma amostra pequena, então reconstruí esse caso

04:44 malformado em quatro versões e executei cada uma 20 vezes. Primeiro, o mesmo JSON cortado: o Qwen-38B acertou quatro de 20, e o Agent Reflex, 18 de 20. Depois, uma página de erro 502 em HTML: ambos os modelos acertaram 20 de 20. E uma resposta em que todos os campos são nulos: ambos acertaram 20 de 20. Então, quando a ferramenta diz claramente que algo deu errado, o modelo original já consegue lidar com isso. O último caso é uma resposta vazia, sem absolutamente nada. O Qwen-38B acertou zero de 20. O Agent Reflex acertou oito de 20.

05:17 Veja o que mostram os erros. Em uma execução, o Qwen-38B me disse que o pedido tinha sido enviado, que o total era US$ 125 e acrescentou que o serviço reserva tinha sido usado. Ele fez uma chamada. Não houve nenhuma chamada à ferramenta reserva. E o Agent Reflex inventou um status e um total também em 12 de 20 execuções, por exemplo, “entregue, 34,50”. Então, ele se recupera com mais frequência, mas não está imune a inventar coisas. E uma ressalva da minha parte: uma tarefa de demonstração, uma quantização de 4 bits feita pela comunidade e de 10 a 20 execuções cada. Isso mostra como ele lida com saídas de ferramentas

05:49 quebradas, não como se sai nos benchmarks do artigo. Então, considere isso um bom começo, não uma conclusão definitiva. Eis o que tiro disso. As falhas evidentes — uma página de erro 502 ou campos nulos — foram tratadas pelos dois modelos. As falhas sutis — uma frase pela metade em JSON ou uma resposta vazia — são onde eles falham, e o Agent Reflex falha menos. Se você não puder trocar de modelo, uma solução simples e barata é um wrapper que transforme uma falha de análise ou uma resposta vazia em um erro explícito. Não testei esse wrapper, mas esse é um caso com que os dois modelos já lidaram.

06:21 Então, quem deveria usar isso? Se o seu agent se comunica com ferramentas instáveis que retornam saídas quebradas, vale a pena testar este Q4 com as suas próprias ferramentas, já que foi o único que continuou tentando. Se suas ferramentas geralmente só atingem o tempo limite ou retornam erros claros, o Qwen-38B já lida com isso no meu teste. Se você está procurando GPUs baratas e confiáveis, eu uso RunPod, e o link está na descrição. O script do benchmark também está na descrição, para você executá-lo no seu sistema e me contar como foi. No próximo vídeo, quero testar isso com servidores MCP reais. Confira o próximo vídeo.

Transcrição original

[00:01] This paper says an 8-billion parameter model jumped from 40.2 to 58.6 on tool use benchmarks just by learning to recover from mistakes. I did not believe that would show up on my laptop, so I broke the tools on purpose six different ways, 10 runs each. In five of the six, it made no difference at all. In one, the original model got one out of 10 and this one got eight. And stay till the end because one of its wrong answers made up a number. All right, this is Agent Reflex 8B on Hugging Face and you can see it says

[00:32] base model Qwen-38B license MIT there on the GitHub repo from the RUC NLPIR group. It has about 75 stars, so this is a very fresh release. The paper went up on the 13th of October and the weights were updated the day after. Now, the idea is simple. Most agents are trained where the tools always work. In real life, a tool times out, returns half a response, or the user says, “Wait, I meant something else.” So, the authors take failures like these and turn them into 1,170 reflection

[01:04] skills, then train in two steps. First, supervised fine-tuning on about 54,000 trajectories, then a preference step they call ORPO. Some summaries call that second step reinforcement learning, but the repo’s own training recipe lists ORPO, so that’s the word I’ll use. Now, let’s look at the numbers on the repo itself. Over the five long horizon tool use benchmarks, Qwen-38B scores 40.2 and Agent Reflex scores 58.6, so that’s 18.4 points. But if you look here, most of that comes

[01:35] from one column. Tau square bench goes from 26.2 to 62.1. A’s bench goes from 54 to 78. And Vita bench, the hardest one, only goes from 11.4 to 17.5. On Agent Noise Bench, which injects failures on purpose, it’s 12.3 to 29.1. So, the average heights that the gain is uneven. These are the authors’ numbers on their own setup with vllm, not mine. So, here’s what I’m running. This is the RTX 4060 laptop GPU with 8 GB and

[02:06] everything here is local. The authors don’t publish ggufs themselves, so I’m using the community quant from Reader Marker, the Q4KM, which is 5 GB. Next to it, the original quant 38B from Olamau, also 4-bit, also 5.2 GB. Same settings for both, temperature 0.68k context. The task is small on purpose. The agent is a support bot with a lookup order tool and a backup tool, and the user asks for the status and total of order 4821. The right answer is shipped

[02:37] 6340 and I scored task completion, not how nice the explanation sounds. If the status or the total is wrong, it’s a fail. Here are the six scenarios. One, clean, the tool just works. Two, timeout, the first call returns a timeout error, the second works. Three, malformed, the first call returns this agson that stops in the middle of the word ship. Four, permission, the main tool returns 403 three times, so the only way out is the backup tool. Five, always down, both tools return 503 forever, so the correct

[03:10] move is to say I could not get it. Six, user correction, it answers and then I say sorry, I meant order 4812. 10 runs of each for each model. That’s 120 episodes. Let’s go ahead and watch one. This is the permission case. You can see it calls lookup order, gets the 403, and on the second call, it switches to the backup tool and gets the answer. And if you look on the right, quant 38B does exactly the same. That’s the thing I did not expect. The original model already knows to retry on a timeout and to

[03:42] switch tools on a 403. Each of these takes about 11 seconds on this card. Here are the results. Clean, 10 out of 10 for both. Timeout, 10 out of 10 for both, permission, 10 for both, always down, 10 for both. And mind you that I only check that it doesn’t invent order details, use a correction, 10 for both. And then, malformed Qwen 38B got one out of 10. Agent Reflex got eight out of 10. Overall, that’s 58 of 60 against 51 of 60.

[04:13] Now, look at what Qwen 38B does with a cut-off JSON. It reads shipped as shipped, says the status is shipped, and just stops after one call. It never tries again. Agent Reflex made 1.8 calls on average in that scenario, so it does retry most of the time. This is the only place on my test where the recovery training shows up clearly. Now, the two misses. In one of them, Agent Reflex said the status is shipped and the total is 8919. That number is not in any tool response. It made it up. Now, 10 runs is thin, so I rebuild that

[04:44] malformed case into four versions and ran 20 each. Each the cut-off JSON again, Qwen 38B four out of 20, Agent Reflex 18 out of 20. Then, an HTML bad gateway page, both models 20 out of 20, and a reply where every field is null, both 20 out of 20. So, when the tool says plainly that something broke, the original model already copes. The last one is an empty reply, nothing at all. Qwen 38B got zero out of 20. Agent Reflex got eight out of 20.

[05:17] Look at what the misses say. In one run, Qwen 38B told me the order was shipped, total $125, and added that the backup service was used. It made one call. There was no backup call. And Agent Reflex 12 times out of 20 invented a status and a total as well, like delivered 34.50. So, it recovers more often, but it’s not immune to making things up. And a caveat on my side, one toy task, a four-bit community quant, 10 to 20 runs each. This tells you how it handles broken

[05:49] tool output, not how it does on the paper’s benchmarks. So, treat it as a good start, not a verdict. So, here’s what I take from that. The loud failures, a bad gateway page, or null fields, both models handled. The quiet ones, a half sentence of JSON, or an empty reply, are where they break, and Agent Reflex breaks less. If you can’t switch models, a wrapper that turns a failed parse or an empty reply into an explicit error is the cheap fix. I haven’t tested that wrapper, but it is the case both models already handled.

[06:21] So, who should use it? If your agent talks to flaky tools that return broken output, it’s worth trying this Q4 on your own tools, since it was the only one that kept going. If your tools mostly time out or return clean errors, Qwen 38B already handles that on my test. If you’re looking for cheap and reliable GPUs, I use RunPod, and the link is in the description. The bench script is in the description, too, so you can run it on your system, and let me know how it goes. Next video, I want to push this with real MCP servers. Check out the next one.