Conteúdo do curso Lição 232 de 250 · Projeto: Agente de Pesquisa que Usa Ferramentas
Projeto: Agente de Pesquisa que Usa Ferramentas

Planejamento + Proteções de laço

Um agente que pode agir também pode agir para sempre. A principal forma de um agente real queimar dinheiro e acordar um engenheiro de plantão é um loop sem freio: ele continua chamando a mesma ferramenta, recebendo a mesma observação, e nunca decide que terminou. Esta lição acrescenta as duas coisas que tornam um agente seguro para rodar de verdade: um pequeno planejador que divide um objetivo em subtarefas ordenadas e uma proteção contra loops que para o agente antes que ele saia de controle.

Primeiro, o planejamento. decompose(goal) transforma um objetivo de uma linha em uma lista numerada de subtarefas. Mantemos isso determinístico e baseado em regras (em produção o LLM faz isso, mas o que importa é o formato): divida o objetivo na palavra "then", tire os espaços de cada parte e numere a partir de 1.

decompose("find the team size then multiply by 2 then report")
# ["1. find the team size", "2. multiply by 2", "3. report"]

Agora a proteção. run_with_guard(policy, state, max_steps) conduz uma política passo a passo, mas se recusa a disparar sem controle. Aqui uma política é uma função policy(state) -> action (uma string com o nome da ação que ela quer executar); aplicar uma ação só a acrescenta a uma lista de histórico. A proteção para por um de três motivos e informa qual:

  • terminou: a política retorna a ação "done" -> para com o motivo "done".
  • sem progresso: a política retorna a mesma ação duas vezes seguidas -> para com o motivo "repeat". Este é o sinal clássico de preso em um loop: o agente não está aprendendo com as observações.
  • orçamento: ela chega a max_steps sem terminar -> para com o motivo "max_steps".
def run_with_guard(policy, state, max_steps):
    history = []
    for _ in range(max_steps):
        action = policy(state)
        if action == "done":
            return {"history": history, "reason": "done"}
        if history and action == history[-1]:
            return {"history": history, "reason": "repeat"}
        history.append(action)
        # let the policy advance its own state here
        ...
    return {"history": history, "reason": "max_steps"}

Retorne um dict {"history": [...], "reason": ...}. A verificação "repeat" é o que salva você: uma política com bug ou confusa que fica emitindo "search" para sempre é parada na segunda ação idêntica, com um motivo que você pode registrar e usar em alertas. Uma política bem comportada, que avança e depois diz "done", termina de forma limpa dentro do orçamento. O avaliador verifica que uma política em loop para com "repeat", uma política descontrolada chega a "max_steps" e uma política boa termina com "done", além de que decompose numera corretamente. Clique em Run para ver os três resultados.

Sua vez

Escreva decompose(goal): split goal em " then ", strip cada parte e retorne elas como "1. part", "2. part", ... Depois escreva run_with_guard(policy, state, max_steps) onde policy(state) retorna uma action string. Execute a policy até max_steps vezes e retorne {"history": [...], "reason": ...}: stop com reason "done" quando a action for "done"; stop com reason "repeat" quando uma action for igual à imediatamente anterior (no-progress); stop com reason "max_steps" se o Budget acabar. Append cada action aceita em history.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.