Coescrito com @VaishShrivas
Ensinamos agentes de CLI a prever respostas do terminal durante RL, junto com a perda GRPO usual em ações. A mudança é pequena: mesmo rollout e forward pass, mas parando de mascarar os tokens de saída do terminal. O efeito é enorme: todas as avaliações melhoram, e os modelos resultantes aprendem de forma mensurável como o terminal se comporta.
Agentes de CLI podem aprender um modelo do terminal de graça — e usá-lo para agir melhor!
Isso é o ECHO: um objetivo híbrido que treina em ambos os lados da interação: o que o agente escreve e o que o terminal escreve de volta.
Confira o paper completo e o código baseado no SkyRL.
Se você estiver muito ocupado para ler este post inteiro, aqui está o que descobrimos:
- O RL padrão de agentes descarta a resposta do ambiente. O GRPO treina em tokens de ação e mascara as respostas do terminal, mesmo que elas já estejam no contexto, já passem pelo modelo e sejam sinais de verdade absoluta sobre como as ações do agente afetaram o ambiente.
- O ECHO corrige isso treinando em ambos os lados da interação. Ele mantém a perda GRPO usual nos tokens de ação e adiciona uma perda simples de entropia cruzada do ambiente nos tokens de saída do terminal. São poucas linhas de código adicionadas a qualquer treinador GRPO. Mesmo rollout e forward pass, apenas uma máscara diferente sobre os logits.
- O ECHO funciona e é de graça! O ECHO melhora o Qwen3-8B, o OpenThinker-Agent-v1-SFT e o Qwen3-14B em todos os benchmarks que testamos. O ECHO também treina até 2,3× mais rápido para o mesmo desempenho. O TerminalBench-2.0 pass@1 quase dobra tanto em 8B (2,7 → 5,2) quanto em 14B (5,2 → 10,8).
- O ECHO ensina dinâmicas do terminal! Em trajetórias não utilizadas, a entropia cruzada dos tokens do ambiente cai drasticamente com o ECHO e mal se move com o GRPO puro. Evidência direta de que o ECHO ensina o modelo como o terminal realmente responde. Os mesmos checkpoints que preveem melhor as saídas do terminal também resolvem mais tarefas.
- O ECHO pode substituir um professor especialista. A partir de um Qwen3-8B base sem demonstrações de especialistas, o ECHO quase iguala o que o GRPO após SFT em demonstrações de especialistas alcança.
- O ECHO permite que agentes se autoaprimorem sem recompensas de verificador! Sem nenhuma recompensa de verificador, o ECHO (sem nenhum GRPO) permite que o agente melhore ainda mais apenas agindo no ambiente e prevendo o que acontece.
Isso começou como uma pergunta simples: se cada comando produz uma resposta do terminal, por que o RL treina apenas no comando?
A Vaish fez todo o trabalho para descobrir isso. Eu contribuí com um experimento bobo de labirinto*, uma opinião forte sobre o título e dizer "puta merda" quando ela me mostrou o primeiro resultado. Agradecimentos ao Ahmed Awadallah por nos dar espaço — e GPUs — para perseguir ideias como essa, mesmo quando elas começam apenas como uma coceira de pesquisa.
Vale notar: a primeira execução em cluster para o ECHO foi lançada em 29 de março 😊
Este trabalho foi feito no AI Frontiers, um laboratório de pesquisa boutique dentro da Microsoft Research.
Como você aprende continuamente?
A primeira vez que essa ideia apareceu foi motivada por uma pergunta simples sobre autoaprimoramento e aprendizado contínuo. Como um agente melhora apenas agindo no mundo?
A Vaish e eu conversávamos desde o outono passado sobre autoaprimoramento em agentes de CLI, ou seja, o que significaria melhorar a partir da interação com o ambiente (também conhecido como terminal), especialmente sem um verificador.
RL sem verificador é um problema em que as pessoas trabalham há anos, e a maioria das tentativas enfrenta o mesmo problema: de onde vem a supervisão, se não há recompensa?
Mais ou menos na mesma época, um post bobo meu no twitter levou a uma chamada com @willccbb discutindo aprendizado contínuo novamente. Durante essa conversa, lembro de ter dito algo bobo como isto:
Talvez aprendizado contínuo seja treinar com base no que o ambiente te devolve como resposta às suas ações.
Isso deve ensinar algo ao modelo, certo?
Acontece que sim!
O mundo é uma função de perda!
Quando um agente age em um ambiente, a resposta do ambiente a essa ação é sempre verdadeira.
Um exemplo do mundo físico: se você acende um interruptor de luz, a luz acende ou não acende. Se não acender, essa é uma resposta legítima: ela te diz algo sobre a lâmpada, ou a fiação, ou o disjuntor, etc. De qualquer forma, o que volta é um pequeno pedaço de informação sobre como o mundo mudou por causa das suas ações sobre ele. Você não é exposto ao mecanismo completo de como a eletricidade, os interruptores e as lâmpadas funcionam, mas você vê o resultado. A luz acendeu? E isso é suficiente para você começar a construir um modelo mental de como acionar interruptores acende luzes.
O terminal funciona mais ou menos da mesma forma.
A saída após um comando bash é um pequeno resumo de como o estado do computador/container mudou depois que o comando foi executado. Você vê stdout, stderr, códigos de saída, listagens de arquivos, etc. Você não vê o estado do kernel ou a árvore de processos ou nada super detalhado.
O que você vê de volta é uma projeção de baixa dimensão do que aconteceu nos bastidores, que é também o que o agente de CLI usará para escolher a próxima ação em direção à tarefa que está tentando realizar. E como no interruptor de luz, isso é sinal suficiente para construir um modelo mental — ou se preferir, um modelo do mundo — de como o sistema se comporta.
A melhor parte é que a saída do terminal, que novamente é um reflexo de como o estado do sistema mudou, é um sinal de supervisão, calculado para você, a cada turno, de graça.
Legal!
O problema é que o RL padrão de agentes (ex.: GRPO no SkyRL) empurra gradientes apenas através dos tokens de ação e ignora os tokens de saída do terminal. Apesar do fato de que a saída do terminal já está no contexto. O modelo presta atenção nela, o forward pass calcula logits para ela, mas o treinador a mascara da perda.
Que desperdício de bons tokens 😊
Então, e se não máscarassemos?
O modelo já está condicionado a esses tokens. Ele já produz uma distribuição de probabilidade sobre eles. Adicionar uma perda de entropia cruzada não custa praticamente nada.
E se fizermos isso… o modelo tem motivos para aprender como o terminal realmente se comporta e pode, portanto, construir, dentro de si, um modelo implícito do sistema sobre o qual está agindo. Para prever o que ls retornará, o modelo precisa rastrear quais arquivos acabou de criar, o que vive onde, etc.
Como o Ilya disse:
Prever bem o próximo token significa que você entende a realidade subjacente que levou à criação daquele token.
No nosso contexto, isso significaria: um agente que é bom em prever saídas do terminal construiu, em um sentido pequeno mas real, um modelo implícito do terminal.
Então, como fazemos o agente prever saídas do terminal?
ECHO: Aprenda um modelo do mundo sem pagar por ele
Um rollout de agente de terminal já intercala dois fluxos de tokens: os tokens de ação do agente e os tokens de observação do ambiente. O GRPO padrão aplica perda apenas nos tokens de ação.
Isso é especialmente desperdiçador porque as recompensas do terminal são esparsas, atrasadas e binárias. No nosso contexto com Qwen3-8B, para muitas tarefas menos de 15% dos rollouts on-policy são bem-sucedidos. Mas trajetórias fracassadas não são dados fracassados: elas ainda contêm listagens de arquivos, erros, logs, stack traces, saídas de grep e outras consequências dos comandos do agente.
Nosso método é a maneira mais vergonhosamente simples de aprender com essas consequências 😊
Adicionamos uma perda de entropia cruzada normalizada por comprimento nos tokens de observação do ambiente, junto com a perda GRPO padrão nos tokens de ação. ECHO é o objetivo híbrido:
onde Actions são as posições das ações do agente e Observations são as posições das saídas do terminal.
Alguns detalhes técnicos:
- O ECHO aprende on-policy. Em vez de treinar em um conjunto congelado de transcrições do terminal do modelo base ou de um professor, o ECHO aprende com as respostas do terminal produzidas pelo modelo atual durante o RL. Conforme o agente melhora, ele explora novas partes do ambiente e obtém supervisão fresca de novas transições ação → observação. Políticas melhores induzem melhor feedback; melhor previsão de feedback dá à política melhores priores de ação. Um loop! Que divertido, não?
- No objetivo conjunto, λ importa. Se for muito pequeno, a perda do ambiente não molda muito o modelo. Se for muito grande, a política pode otimizar para saídas previsíveis em vez de progresso na tarefa. Tem que equilibrar!
- Os tokens alvo importam. Treinamos na saída real do terminal, não em avisos do harness. Avisos são fáceis de memorizar; o sinal útil é a resposta real do terminal — nomes de arquivos, stack traces e mensagens de erro.
Então, quanto isso custa?
Um leitor astuto pode perguntar:
o backward pass não fica mais caro se você está retropropagando gradientes em mais posições de tokens?
Quase não. A parte cara do backprop são os matmuls através das camadas de atenção e MLP, e elas rodam sobre a mesma sequência de tokens, independentemente de quais posições de saída contribuem para a perda. Os logits em cada posição de resposta já são calculados para o GRPO. A máscara de ação e a máscara de observação apenas coletam subconjuntos diferentes deles para termos de perda diferentes.
Pause aqui por um segundo: adicionamos uma perda de modelagem do mundo, e o custo é basicamente ZERO! Sem rollouts extras, modelo professor e sem forward pass extra.
O ECHO ajuda a treinar um agente de CLI melhor?
Fizemos a comparação mais limpa possível em tarefas de terminal multi-turno: mesmos modelos, mesma receita GRPO, mesmas tarefas, mesmo orçamento de rollout e turno, mesmo número de passos de treinamento. Recompensa = 1 se o agente passar nos casos de teste após n turnos, 0 se falhar.
A única diferença é se os tokens de saída do terminal também entram na perda.
As curvas rosa são ECHO e as verde-azuladas são GRPO. Em todos os tamanhos de modelo e fatias de avaliação, a resposta é a mesma: adicionar a previsão do ambiente torna o agente substancialmente melhor.
O ECHO melhora consistentemente o desempenho em todos os três conjuntos de validação retidos — as curvas rosa se separam das verde-azuladas no início e geralmente permanecem acima.
O ECHO também aprende substancialmente mais rápido: o ECHO iguala o desempenho de 500 passos do GRPO no Terminal-Bench Lite 280 passos mais rápido! Uma aceleração de 2,3x e continua subindo 😊
Esses resultados substanciam nossa intuição por trás do ECHO. O GRPO treina apenas com recompensas binárias de resultado esparsas. Para domínios difíceis como tarefas de terminal onde a taxa de aprovação é baixa para modelos pequenos, isso se traduz em pouco ou nenhum sinal para muitas tarefas.
O ECHO torna o treinamento muito mais eficiente em termos de amostras ao transformar ações fracassadas em supervisão. Mesmo quando uma ação não resolve a tarefa, a resposta do terminal ainda ensina ao modelo o que aquela ação causou! E prever as consequências de ações fracassadas pode ajudar o agente a escolher ações melhores.
Se você preferir ver os números nas avaliações, a mesma história em forma de tabela:
Veja a última linha em cada bloco: ECHO. TerminalBench-2.0 pass@1 quase dobra em 8B (2,7 → 5,2) e 14B (5,2 → 10,8). E, importantemente, isso não vem de dados extras, rollouts, um modelo professor ou um verificador diferente. O rollout já continha a resposta do terminal. O ECHO apenas aprende com ela.
"Desempenho quase dobra sem custo extra" é uma frase que você muito raramente lê ao longo de toda a sua carreira de pesquisa 😊.
O ECHO supera substancialmente o desempenho do GRPO em todos os benchmarks e tamanhos de modelo, é muito mais eficiente em termos de amostras e custa basicamente nada. Você aprende um modelo do mundo conforme sua política melhora, o que ajuda ela a melhorar mais rápido.
Os céticos, no entanto, podem contestar: você realmente aprende um modelo do mundo?
Vamos ver!
O ECHO realmente aprende dinâmicas do terminal?
Vamos ser um pouco cautelosos aqui porque o pessoal da modelagem do mundo pode ser um pouco intenso.
Não vamos afirmar que o ECHO aprende um modelo do mundo no sentido mais forte. Mas vamos afirmar que o ECHO treina uma política cujos estados ocultos absorveram algo sobre como o terminal se comporta, e cuja capacidade de prever o que o terminal fará melhorou de forma mensurável.
Se você inverter a citação do Ilya, obtém uma versão mais falseável. Para nosso contexto, seria algo assim:
Se o modelo aprendeu dinâmicas do terminal, ele tem que ser bom em prever a saída do terminal.
Porque não há outra maneira de atribuir consistentemente alta probabilidade aos tokens certos. Um modelo que é um melhor preditor é, em termos de teoria da informação, um melhor compressor do sistema que está prevendo.
Então a questão se torna empírica: o ECHO realmente torna o modelo um melhor preditor da saída do terminal?
Sim. Por muito.
Para tornar este teste limpo, usamos um modelo professor mais forte, Qwen 3 32B (não usado em nenhuma de nossas execuções de treinamento) para gerar trajetórias para cada um de nossos conjuntos de validação. Então avaliamos nossas políticas iniciais, políticas treinadas com GRPO e políticas treinadas com ECHO e medimos o quão "surpreso" cada modelo estava pelos tokens de saída do terminal resultantes.
O padrão é o mesmo em todos os painéis: o GRPO mal altera a entropia cruzada dos tokens do ambiente em relação à política inicial. O ECHO a reduz drasticamente.
Então não vamos dizer modelo do mundo com M maiúsculo. Mas vamos dizer isto:
O ECHO produz políticas que são mensuravelmente melhores em comprimir dinâmicas do terminal, em trajetórias que elas não geraram.
Que é a versão operacional da afirmação que o título está fazendo, e a versão que é totalmente defensável.
Descoberta surpreendente 1: ECHO reduz a dependência de SFT especialista
Uma receita comum para RL de agentes é: primeiro, clone o comportamento de trajetórias especialistas de um modelo mais forte, depois execute RL. Isso é especialmente comum para agentes de terminal, onde a recompensa é esparsa e o espaço de ação é enorme.
No nosso contexto, a linha de base SFT especialista é OpenThoughts-Agent-v1-SFT (OT-SFT): Qwen3-8B ajustado em demonstrações de agente de terminal geradas por um professor GLM-4.6 mais forte.
Então perguntamos: quanto desse benefício do SFT especialista o ECHO pode recuperar sem clonar o comportamento do professor?
O ECHO pode permitir que você pule o SFT especialista? No nosso contexto, principalmente sim!
Esta figura compara três execuções: GRPO puro no modelo base, ECHO no modelo base e GRPO no modelo com SFT (SFT + GRPO). Relativo ao gap entre GRPO e SFT+GRPO (ex.: o ganho que partir do SFT proporciona), o ECHO recupera 104% do ganho no ITD, 89% no Terminal Bench Lite (TBLite) e 50% no TerminalBench-2.0 (TB2) pass@1.
O resultado sugere que grande parte do valor do SFT especialista pode vir de ensinar ao modelo um prior de interação, não apenas um prior de estratégia especialista. Demonstrações especialistas mostram tanto como se comportar como um agente de terminal — inspecionar arquivos, executar testes, seguir tracebacks, etc — quanto o que um especialista faria em estados específicos. O ECHO não imita essas escolhas especialistas. Em vez disso, treina o modelo para prever as consequências no terminal de suas próprias ações, para que ele aprenda quais comandos expõem estado útil, quais erros são diagnósticos e quais tokens de saída do terminal sinalizam progresso. Estratégias melhores podem então emergir através da interação em vez da imitação.
Isso também ajuda a interpretar a divisão dos benchmarks. No ITD e TBLite, o ECHO quase iguala o SFT especialista, sugerindo que grande parte da vantagem do SFT ali vem de um melhor modelo de interação com o terminal. No TB2, o ECHO ainda recupera 50% substanciais do gap sem demonstrações. O gap restante é consistente com o TB2 sendo mais difícil e distribucionalmente mais distante do conjunto de treinamento.
Não trataríamos isso como um teto fixo: treinamento mais amplo ou mais longo em tarefas semelhantes ao TB2 deve melhorar ainda mais o agente.
Portanto, a conclusão não é que o SFT especialista esteja obsoleto, mas que grande parte do que o SFT especialista proporciona pode ser um melhor modelo de interação com o terminal, e essa parte pode ser aprendida diretamente do ambiente.
Resumo: O terminal é o professor!
Descoberta surpreendente 2: Faíscas de autoaprimoramento sem recompensas
Até agora, o ECHO tem sido GRPO com uma perda auxiliar do ambiente. O verificador ainda diz ao agente se ele resolveu a tarefa, e o GRPO atualiza o modelo nos tokens de ação. Então, configuração RL padrão, com um pequeno termo extra.
Mas se o ECHO está genuinamente ensinando algo à política sobre como o terminal se comporta, então talvez não precisemos do sinal do verificador.
Perguntamos: O que acontece se desligarmos o verificador? Sem recompensas para aprender, apenas isto:
Isto é, o modelo age, observa, atualiza apenas prevendo as saídas do terminal como consequência de suas próprias ações.
Isso parece que não deveria melhorar o desempenho da tarefa. Não há rótulo dizendo qual ação foi boa. Se a política melhora, tem que ser porque aprender a prever o terminal indiretamente remodela os priores de ação da política.
Então tentamos!
Pegamos nosso checkpoint mais forte Qwen3-8B+ECHO, removemos o termo GRPO completamente e treinamos por mais 100 passos em tarefas retidas usando apenas a perda de entropia cruzada do ambiente. A pergunta era se o modelo poderia melhorar em tarefas OOD que nunca tinha visto antes, puramente interagindo com o ambiente e prevendo o que voltava.
Essa ideia louca funcionou? Mais ou menos!
No val100 (dentro da distribuição): +3,8 pp. No ITD: +5,2 pp. No PyTerm (um conjunto OOD retido de tarefas de terminal com uso intenso de Python): +10,0 pp após filtrar para trajetórias limpas com chamadas de ferramenta.
O treinamento apenas com ambiente melhora a política quando a saída do terminal é uma supervisão útil. Sem sinal de recompensa, o modelo treina apenas para prever as saídas causadas por suas próprias ações, então os ganhos dependem se essas saídas expõem dinâmicas úteis.
No val100, que é próximo da mistura de treinamento, o ganho é real mas pequeno: +3,8 pp antes da saturação. A política já aprendeu a maioria das dinâmicas locais durante o treinamento ECHO.
No ITD, a política inicial mais fraca produz trajetórias ruidosas — comandos inválidos, erros de análise, loops sem saída. Filtrar para rollouts limpos elimina o ruído do sinal e dá +5,2 pp.
Apenas trajetórias limpas não são suficientes, no entanto. A mesma filtragem não melhorou consistentemente o TBLite, enquanto o PyTerm começou de uma taxa de aprovação similar mas melhorou sob a mesma receita — sugerindo que o gargalo não é apenas a força da política. A diferença chave é o quão informativas são as observações: tarefas Python dão feedback denso ligado à ação — código → traceback → correção — enquanto tarefas de terminal mais amplas revelam estado mais indiretamente através de arquivos, configs e configuração de múltiplas etapas.
Acreditamos que a adaptação sem verificador é possível: uma vez que o RL produziu um modelo de exploração decente, o agente pode às vezes continuar melhorando apenas a partir das consequências — mas apenas quando seus rollouts são limpos e o feedback do terminal é informativo. Isso É a parte surpreendente. Não que o agente se aprimore perfeitamente, mas que ele se aprimore de alguma forma, a partir de nada além de agir e prever o que volta.
Onde isso nos deixa
A lição central do ECHO é simples: rollouts de agentes contêm mais supervisão do que apenas a recompensa final, e devemos usá-la.
Cada comando que um agente executa produz uma resposta do terminal — stdout, erros, traces, arquivos, logs, etc — e o RL padrão usa esses tokens apenas como contexto para a próxima ação. O ECHO os transforma em alvos de treinamento. Nenhum modelo professor, rollouts extras ou modelo de mundo separado são necessários. Apenas paramos de jogar fora os tokens do ambiente que já estão na transcrição.
Essa pequena mudança levou a três resultados surpreendentes: desempenho RL mais forte, dependência muito menor de SFT especialista e, em alguns contextos, autoaprimoramento sem verificador apenas a partir da interação com o ambiente. Não achamos que isso significa que recompensas ou demonstrações estejam obsoletas. Trajetórias especialistas ainda ensinam estratégia e verificadores fornecem o sinal mais limpo no nível da tarefa. Mas o ECHO sugere que entre "imitar o especialista" e "esperar pela recompensa esparsa", há uma fonte densa e subutilizada de supervisão: as consequências das próprias ações do agente.
A ideia mais ampla é uma continuação da predição auxiliar que tem uma longa história em RL, e trabalhos recentes reviveram objetivos de modelagem do mundo para agentes LLM, ex.: Agent Learning via Early Experience usa sinal de ação-consequência como um estágio pré-RL, VAGEN adiciona uma recompensa de modelagem do mundo para agentes VLM, RWML pré-treina em predição do próximo estado, e CWM treina um modelo de código em trajetórias de observação-ação. O ECHO é a versão online, dentro do loop RL, com sabor de CLI, da mesma ideia.
Até onde essa ideia pode ir?
O próximo passo é tornar esse sinal do ambiente mais potente — e testar o quão longe ele generaliza. O ECHO usa saídas brutas do terminal porque elas já estão no rollout, mas o melhor alvo de aprendizado pode ser uma representação mais limpa e compacta: resumos ou visões do estado relevantes para a tarefa. Também: Em quais observações devemos treinar? Quando devemos filtrar trajetórias? Como devemos ponderar a predição do ambiente contra a otimização da política? A mesma ideia pode funcionar além de terminais: para agentes de navegador, sistemas multi-ferramenta, agentes de codificação de longo horizonte ou assistentes voltados ao usuário onde acompanhamentos, correções e preferências são outra forma de feedback de interação?
Nossa aposta é que em qualquer lugar onde um agente age e o mundo responde em tokens, esses tokens de resposta — ou melhores representações deles — devem fazer parte do sinal de aprendizado. O ECHO é a versão mais simples dessa ideia que conseguimos pensar, e suspeitamos que alguma forma de predição de tokens do ambiente será padrão em treinadores RL de agentes até o final de 2026.
Confira o paper completo e o código baseado no SkyRL.
Experimente o ECHO e nos diga o quanto mais rápido seu agente treinou.
Nota de rodapé: treinando um modelo de mundo de labirinto no meu laptop… mais ou menos
Lembra quando eu disse que "contribuí com um experimento bobo de labirinto"? Aqui está o experimento bobo de labirinto
A configuração era uma versão minúscula do ECHO: Um labirinto de grade em um terminal minúsculo. O agente (um transformer de 10M em um loop) emite uma direção — cima, baixo, esquerda, direita — e o terminal responde com onde o agente está em relação aos seus "vizinhos" (é basicamente um problema de busca de caminho em uma grade 2D) e a distância até o destino. Então o rollout se parece exatamente (para valores pequenos de exatamente) com um rollout de agente de CLI, apenas muito mais simples 😊: ação → resposta do ambiente → ação → resposta do ambiente etc.
Testei duas condições em um transformer de 10M params treinado do zero: 1) treinar apenas nos tokens de ação 2) treinar nos tokens de ação e na resposta do terminal (vizinhos, distância, etc). Todos treinados em labirintos novos de 6×6 / 7×7 / 8×8
Essa coisa de labirinto é um paper da Nature? Não. Mas: acho que há um ponto que venho defendendo que continua se generalizando.
Quase toda ideia limpa tem um microcosmo: uma versão reduzida que você pode executar em um laptop em uma noite que te diz se a ideia vale a pena ser escalada.
O labirinto não provou que o ECHO funcionaria. Ele me deu convicção suficiente para enviar uma mensagem para a Vaish no Teams em vez de esquecer a ideia. Acontece que a Vaish estava circulando em torno da mesma ideia independentemente e quando a primeira execução do cluster dela voltou com resultados, fiquei emocionado e genuinamente surpreso. O labirinto do ECHO tinha sugerido que a direção estava certa, mas não poderia ter previsto dobrar os scores do TerminalBench, recuperar a maior parte do SFT especialista ou autoaprimoramento sem recompensas. Esses foram os resultados da Vaish. "Resolver mais ou menos um labirinto 6×6" e "dobrar no TerminalBench" são estados epistêmicos muito diferentes.
Mas o objetivo deste adendo não é dizer que o laptop substitui o experimento em cluster. O ponto é que a maioria das minhas ideias está errada e o experimento no laptop (com a ajuda do Claude Code e do Codex) me mostra quais descartar antes que custem tempo de outras pessoas. De vez em quando, uma ideia sobrevive, e quando isso acontece, talvez ela conquiste o direito ao tempo e aos GPUs de um colaborador.
O ECHO é uma delas.
