Dê a um modelo ferramentas e um laço

Cerca de 22 minutos min de leitura, com 4 exemplos em 8 seções.

Edição 2026.11.2 Exemplos aprovados em 20 de nov de 2026 64 de 64 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.2. Leia o original

Ao final deste capítulo, você será capaz de executar um modelo em um laço que lhe dá três ferramentas: uma lê um arquivo, uma executa os testes e uma termina com um arquivo alterado. O laço para quando o modelo finaliza, quando esgota os passos ou quando deixa de fazer chamadas. Você o executará primeiro com um modelo roteirizado que resolve a tarefa e depois com um modelo aberto gravado que não a resolve, e verá onde esse modelo erra.

O agente deste capítulo mantém unitcraft, uma pequena biblioteca Python que lê, converte e formata grandezas físicas escritas como texto, como 3.5 kg. O agente recebe uma issue que um mantenedor registrou e propõe uma alteração no código da biblioteca. Ele pode executar os testes visíveis na sua própria cópia, mas nunca vê a verificação oculta que decide se uma alteração conta como concluída. Essa separação é deliberada. Um agente que pode ler o seu próprio avaliador aprende o avaliador, e as medições do livro no capítulo 10 não significariam nada.

A carta de Andrew Ng em The Batch, edição 379, datada de 13 de novembro de 2026, descreve um harness de agente como o código que envolve um LLM e lhe fornece contexto, ferramentas e salvaguardas. Este livro usa o termo com o mesmo sentido. O modelo toma as decisões. O harness fornece o laço, as ferramentas e os limites sobre o que essas ferramentas podem fazer, e a maior parte deste livro trata dessa segunda parte.

A primeira tarefa, T-01, é uma correção em um único arquivo: a alteração vai em unitcraft/format.py. A suíte visível falha em tests/test_format.py, e a issue diz: "format_quantity descarta os zeros à direita: 3.5 kg é impresso como 3.5 kg, e o padrão são duas casas decimais." Assim, a saída esperada para 3.5 kg é 3.50 kg. Uma pessoa abriria unitcraft/format.py, leria o código, faria a alteração e executaria os testes novamente. O agente precisa fazer as mesmas coisas em ordem, sem uma pessoa entre as etapas, e o harness precisa garantir que a ordem se mantenha mesmo quando o modelo escorregar.

Este capítulo cobre uma tarefa do início ao fim. Ele explica com o que o agente começa, o laço que o executa, as ferramentas que ele chama e a primeira regra que o detém. Em seguida, executa o laço duas vezes, uma com um modelo roteirizado e outra com um modelo gravado, e conta o que aconteceu.

O que o agente faz em uma tarefa

O agente começa com duas mensagens: um prompt de sistema que nomeia suas ferramentas e os argumentos delas, e o texto do problema. Nada mais sobre a tarefa chega ao modelo. O agente nunca toca no caso em si. O arcabouço cria uma cópia de trabalho da biblioteca para cada execução, e toda escrita que o agente faz vai apenas para essa cópia. Quando a execução termina, a cópia é avaliada e depois descartada, de modo que uma execução não pode deixar alterações para a próxima.

Uma correção é considerada concluída quando duas coisas são verdadeiras. A verificação oculta passa na cópia, e a execução termina com uma chamada a finish. Para T-01, a verificação oculta é H-01, um arquivo pytest escrito a partir do texto do problema. Ela afirma apenas uma coisa: que format_quantity completa 3.5, 0 e 12 kg com duas casas decimais, como 3.50 kg, 0.00 kg e 12.00 kg. O arcabouço copia esse arquivo para uma cópia nova da biblioteca após a execução, de modo que o agente nunca o lê. O capítulo 10 aplica a mesma regra a todo o conjunto de tarefas. Aplicar uma alteração à biblioteca de casos é uma decisão separada, e o capítulo 6 é onde um portão de aprovação a faz.

A regra também fecha um atalho que um modelo pode tomar. Ele pode editar os testes visíveis até que passem. Para T-01, o arquivo de tarefa diz que a pasta tests deve permanecer inalterada, de modo que o avaliador compara essa pasta com o caso byte a byte, e um teste editado torna a execução não concluída, mesmo quando a verificação oculta passa. Um modelo que está adivinhando uma correção pode recorrer a esse atalho sem qualquer intenção de trapacear, e a regra é o que impede que ele seja contabilizado.

Carregar T-01 a partir do arquivo de tarefa e listar os arquivos do caso leva um exemplo curto.

read-the-issue.py Python 3.12.15 Aprovado
"""The issue the agent starts from, task T-01, and the case's files in sorted order. The model reads only theissue and the system prompt, so these are what its first request holds about the task."""from lib.case import CASE, case_files, load_taskstask = load_tasks(only=["T-01"])[0]print("task:", task.id)print("issue:", task.issue)files = case_files(CASE)print("case files:", len(files))for name in files:    print(" ", name)
Saídapython read-the-issue.py
task: T-01
issue: `format_quantity` drops the trailing zeros: 3.5 kg prints as `3.5 kg`, and the default is two places. CI is red on `tests/test_format.py`.
case files: 25
  .github/workflows/test.yml
  README.md
  pyproject.toml
  tests/test_arith.py
  tests/test_cli.py
  tests/test_convert.py
  tests/test_format.py
  tests/test_parse.py
  tests/test_rounding.py
  tests/test_table.py
  tests/test_temperature.py
  unitcraft/__init__.py
  unitcraft/__main__.py
  unitcraft/arith.py
  unitcraft/cli.py
  unitcraft/convert.py
  unitcraft/errors.py
  unitcraft/format.py
  unitcraft/parse.py
  unitcraft/prefixes.py
  unitcraft/quantity.py
  unitcraft/rounding.py
  unitcraft/table.py
  unitcraft/temperature.py
  unitcraft/units.py

A saída imprime o problema e, em seguida, os arquivos do caso em ordem alfabética. O problema é o único texto específico da tarefa na primeira requisição do modelo, de modo que cada passo posterior depende do que essa primeira requisição continha. O caso tem 25 arquivos, e o agente pode ler qualquer um deles a partir de sua cópia.

Regra prática: Avalie uma execução somente contra a sua própria cópia e a verificação da sua tarefa. Nunca a avalie contra o caso em si, porque uma alteração que tivesse chegado ao caso contaria para uma execução que não a conquistou.

Um laço em cerca de setenta linhas

Um modelo produz texto, e o harness transforma parte desse texto em ações. Cada passo envia ao modelo as mensagens até ali, junto com os esquemas das ferramentas. A resposta volta como texto. O harness lê a chamada de ferramenta dentro dela, executa a ferramenta na cópia de trabalho descartável, acrescenta o resultado às mensagens e volta ao início. O modelo nunca executa nada por conta própria. A documentação da Anthropic sobre uso de ferramentas define o contrato nesses termos: o modelo emite uma solicitação estruturada, a aplicação executa a operação, e o resultado volta para a conversa (Como funciona o uso de ferramentas).

O laço é _loop em examples/lib/loop.py, com cerca de setenta linhas. O arquivo também traz regras para capítulos posteriores: as paradas opcionais em Stops vêm desativadas por padrão, e uma resposta interrompida no limite de tokens é recusada, seja qual for a configuração. Nenhuma execução deste capítulo chega a nenhuma das duas situações. Um passo é uma chamada ao modelo. Uma chamada de ferramenta é uma solicitação dentro de um passo, e uma resposta pode conter mais de uma. O laço age sobre a primeira solicitação e responde a cada uma das outras com um erro que informa que ela não foi executada. Cada solicitação recebe um ID de um contador, e esse ID vai na mensagem de resultado da ferramenta que a responde. A mensagem do assistente que contém a resposta não leva ID, e o rastro também não guarda nenhum. O rastro, em lib/trace.py, guarda uma linha por passo: o número do passo, a ferramenta chamada e o que voltou. Cada resposta também permanece nas mensagens, e por isso o modelo vê seus próprios passos anteriores na chamada seguinte, e por isso a solicitação cresce a cada passo.

A resposta do modelo é texto simples, e sua chamada de ferramenta tem um formato fixo: JSON dentro de tags <tool_call>. O template de conversa no arquivo do modelo pede esse formato, um objeto JSON com o nome da função e os argumentos dentro das tags (o arquivo do modelo na revisão fixada). As respostas registradas usam esse formato, e o harness lê somente o que está dentro das tags:

<tool_call>
{"name": "read_file", "arguments": {"path": "<case-relative path>"}}
</tool_call>

O texto fora das tags é ignorado, de modo que uma resposta pode trazer prosa antes da chamada. Um bloco que não puder ser interpretado não é executado. O harness o registra como chamada malformada e devolve o motivo ao modelo como resultado de erro, para que ele possa tentar de novo.

Ao longo da execução, as mensagens crescem em ordem fixa: o prompt de sistema, a issue e, depois, cada resposta seguida do resultado de sua chamada. Nada é resumido e nada é descartado. Isso torna a transcrição legível, e faz com que o custo de cada passo cresça em função do anterior. O capítulo 5 trata do que fazer quando esse crescimento chega à janela do modelo. As execuções deste capítulo são curtas e ainda não precisam disso.

O ReAct intercala raciocínio escrito com ações, e Yao e colaboradores relataram que o raciocínio ajuda o modelo a manter e revisar um plano, e a lidar com exceções (Yao et al., ReAct). Este laço mantém apenas as ações e não pede ao modelo nenhum raciocínio entre elas. Seu prompt de sistema diz “Responda somente com uma chamada de ferramenta”, e o analisador ignora qualquer prosa que o modelo escreva mesmo assim.

Regra prática: Mantenha nas mensagens cada solicitação e o seu resultado, e dê a cada resultado o ID da solicitação que ele responde. Um laço que descarta um resultado deixa o modelo sem resposta para sua solicitação, e as mensagens são onde essa lacuna aparece.

Duas ferramentas e uma ferramenta de parada

O agente precisa ler, testar e alterar, então o capítulo lhe dá uma ferramenta para cada tarefa. A ferramenta de alteração também é a ferramenta de parada, pois, neste design, uma alteração encerra a execução.

Ferramenta Argumentos O que é devolvido Encerra a execução?
read_file path, um caminho dentro da cópia temporária do caso feita para a execução o texto do arquivo, ou um erro não
run_tests nenhum as contagens e os nomes dos testes que falham, da suíte visível na cópia não
finish path e text, o novo arquivo inteiro as contagens e os testes que falham depois que a alteração é gravada sim

read_file devolve o arquivo inteiro, e um caminho fora da cópia é recusado. run_tests executa a suíte visível na cópia e devolve suas contagens e os nomes dos testes que falham, não a saída completa. Uma suíte que ultrapassa o limite de tempo é interrompida, junto com seu grupo de processos. finish recebe o novo texto de um arquivo, grava-o na cópia, executa a suíte visível e encerra a execução. Se a gravação for recusada, o erro volta como resultado de ferramenta e a execução continua, para que o modelo tenha outra tentativa.

Neste capítulo, as ferramentas são executadas dentro do próprio processo do harness, sobre a cópia. O Capítulo 7 executa os testes, o único comando que essas ferramentas iniciam, em um sandbox.

Uma ferramenta que lê arquivos precisa decidir quais caminhos vai ler. Chamar read_file com dois caminhos fora do caso mostra o que o modelo recebe de volta quando pede um deles.

tool-refusal.py Python 3.12.15 · pydantic 2.14.3 Aprovado
"""The read tool refuses a path outside the case, and the refusal comes back as text the model can read. Only readsare tried, and a refused path never reaches the disk."""from lib.case import CASEfrom lib.tools import CH1, WorkspaceABSOLUTE = "/etc/secret.txt"ws = Workspace(CASE)for path in ("../secret.txt", ABSOLUTE):    result = CH1.call(ws, "read_file", {"path": path})    # An absolute path differs on every machine, so the output shows a placeholder for it.    print("refused:", result.text.replace(ABSOLUTE, "<absolute path>"))
Saídapython tool-refusal.py
refused: error: path outside the case: ../secret.txt
refused: error: path outside the case: <absolute path>

Os dois caminhos são recusados, e cada recusa é um resultado de ferramenta. O modelo lê esse resultado na etapa seguinte como qualquer outro, então pode corrigir o caminho e tentar de novo. Nenhuma das leituras recusadas chega ao disco.

Regra prática: Dê a cada ferramenta uma única tarefa, e deixe apenas a ferramenta de parada encerrar uma execução. Uma leitura ou gravação recusada deve voltar ao modelo como um erro a partir do qual ele possa agir, e nunca deve interromper o laço.

Pare quando terminar, ou quando o orçamento acabar

Um laço sem saída roda até que alguém o pare, e cada passo custa tokens. Por isso, cada execução termina de uma de três maneiras, e a execução registra qual delas como ended. O modelo chama finish, e a execução termina com a sua alteração. Ou a execução atinge o orçamento de passos, que é de oito passos para o conjunto de ferramentas deste capítulo, e termina como step_cap. Ou o modelo responde duas vezes seguidas sem nenhuma chamada de ferramenta. A primeira resposta desse tipo recebe uma nova tentativa, com uma mensagem que pede uma chamada de ferramenta. A segunda termina a execução como no_tool_call.

Uma chamada a uma ferramenta que não existe volta como um resultado de erro, e a execução continua. O laço não para numa chamada ruim. Ele conta a chamada, devolve o erro e aguarda o próximo passo. O orçamento é o que impede que um modelo que continua fazendo chamadas ruins rode para sempre. O orçamento conta chamadas ao modelo, não segundos, então a mesma execução termina no mesmo passo em qualquer máquina. O orçamento também é um limite separado do tamanho do contexto: uma execução pode atingir o orçamento de passos com espaço sobrando na janela, ou pode esgotar a janela antes. A janela não é um limite que este capítulo impõe.

Capítulo 2 acrescenta as demais regras de parada. Elas cobrem uma execução que repete a mesma chamada, uma execução que faz edições sem mover a contagem de testes, e uma execução que deveria fazer uma pergunta à pessoa em vez de continuar. O laço deste capítulo não tem nenhuma delas, então um modelo que fica preso em repetição vai continuar repetindo até o oitavo passo.

Regra prática: Defina o orçamento de passos antes de a execução começar, e trate-o como um limite rígido. Uma execução que atinge o orçamento não terminou, qualquer que seja a aparência do seu último passo, e deve ser relatada como não concluída.

Execute em um modelo roteirizado

Com o loop, suas ferramentas e seu orçamento prontos, a primeira execução usa um modelo cujas respostas você escreve por conta própria. Um modelo roteirizado devolve as respostas que você lhe der, na ordem em que foram dadas, e nada além disso. Isso o torna um teste limpo do loop: qualquer falha na execução é do loop, e não do modelo, e a execução mostra o que o loop faz com respostas corretas, e não o que um modelo escolheria. Quatro respostas roteirizadas para T-01 leem a implementação, leem o teste, executam a suíte visível e terminam com um arquivo corrigido.

scripted-loop.py Python 3.12.15 · pydantic 2.14.3 Aprovado
"""Four scripted replies solve T-01 through the step loop: read the file, read its test, run the visible suite,then finish with the fixed file. The model is scripted, so the output shows the loop's steps and not a model's choices."""from lib.case import load_tasksfrom lib.chapter1 import SOLUTION, call, reportfrom lib.models import ScriptedModelfrom lib.tools import CH1task = load_tasks(only=["T-01"])[0]model = ScriptedModel([    call("read_file", path="unitcraft/format.py"),    call("read_file", path="tests/test_format.py"),    call("run_tests"),    call("finish", path="unitcraft/format.py", text=SOLUTION.read_text(encoding="utf-8")),])run, done = report(model, task, CH1)  # CH1: three tools, their system prompt and a budget of eight steps; report prints the trace and scores the runassert done, "the scripted run should solve T-01"
Saídapython scripted-loop.py
step 1: read_file: 23 lines
step 2: read_file: 27 lines
step 3: run_tests: 8 failed, 22 passed
step 4: finish: 7 failed, 23 passed
steps: 4
tool calls: 4
ended: finish

A execução resolve T-01 em quatro passos, que é tudo o que uma execução roteirizada pode provar: o loop leva respostas corretas até uma verificação que passa. O arquivo corrigido é a solução do próprio livro, guardada com os dados do caso, e o exemplo afirma que a execução é considerada concluída.

Leia a saída em ordem. Cada linha nomeia uma chamada e o que voltou dela, de modo que as linhas juntas mostram o que o modelo tinha diante de si em cada passo. Os contadores mudam entre o passo 3 e o passo 4: a correção leva a suíte visível de 8 falhas para 7 falhas, e o teste que a issue descreve agora passa. As sete que restam falham em outros testes da mesma suíte visível. A verificação que conta para T-01 é H-01, e ela passa. A execução leva 4 passos e faz 4 chamadas de ferramenta, uma por passo, e termina como finish.

Regra prática: Execute o loop em um modelo roteirizado antes de executá-lo em qualquer modelo. Se a execução roteirizada falhar, a falha está no harness, e uma execução com modelo apenas a esconderia. Se a execução roteirizada passar e a execução com modelo falhar, a falha está no modelo ou no prompt.

Execute com o modelo gravado

A execução gravada vem do Qwen3-4B-Instruct-2507, um modelo aberto quantizado para Q4_K_M e executado em uma CPU com temperatura 0 e semente fixa. As respostas foram salvas como o texto bruto que ele produziu, em uma gravação cujo manifesto indica o modelo, sua revisão, o hash do prompt e a contagem de tokens. A reprodução verifica se cada requisição corresponde à que a gravação contém, sendo uma requisição as mensagens e os esquemas das ferramentas enviados naquela etapa, e então devolve a resposta gravada.

recorded-run.py Python 3.12.15 · pydantic 2.14.3 Aprovado
"""The recorded run of T-01, replayed step by step: each request must match the one recorded, and the replies arethe recorded text, mistakes included. The run stops at the step cap without a finish, so the task is not done."""from lib.case import load_tasksfrom lib.chapter1 import Recorder, reportfrom lib.models import ReplayModelfrom lib.tools import CH1from collections import Countertask = load_tasks(only=["T-01"])[0]model = Recorder(ReplayModel("chapter-1-t01", "T-01"))run, done = report(model, task, CH1)assert not done, "the recorded run should not solve T-01"reasons = [reason for reply in model.replies for reason in reply.malformed]print("malformed calls:", len(reasons))for reason, count in sorted(Counter(reasons).items()):    print(f"  {count} x {reason}")assert all('"text": """' in reply.text for reply in model.replies[2:]), "from step 3 the call's text opens with triple quotes"print("prompt tokens:", run.prompt_tokens)print("completion tokens:", run.completion_tokens)
Saídapython recorded-run.py
step 1: read_file: 23 lines
step 2: run_tests: 8 failed, 22 passed
step 3: malformed: error: malformed call
step 4: malformed: error: malformed call
step 5: malformed: error: malformed call
step 6: malformed: error: malformed call
step 7: malformed: error: malformed call
step 8: malformed: error: malformed call
steps: 8
tool calls: 8
ended: step_cap
malformed calls: 6
  6 x not JSON (Expecting ',' delimiter)
prompt tokens: 13009
completion tokens: 2128

O modelo gravado nunca termina. Suas duas primeiras etapas são chamadas válidas: uma read_file, depois uma run_tests. A partir da terceira etapa, cada resposta é uma chamada finish que traz um arquivo inteiro novo, e cada uma dessas chamadas falha na análise. Isso acontece 6 vezes, sempre pelo mesmo motivo, e a execução termina como step_cap após 8 etapas e 8 chamadas de ferramenta. O harness devolve cada falha como um resultado de erro, e o modelo responde com uma chamada finish de mesmo formato.

O formato de cada chamada que falha é este. O arquivo foi omitido, e o texto da chamada aparece com ...:

<tool_call>
{"name": "finish", "arguments": {"path": "unitcraft/format.py", "text": """ ...the whole file...\""}}
</tool_call>

O valor começa com três aspas. O JSON lê as duas primeiras como uma string vazia, então o analisador para na terceira, onde espera uma vírgula. O valor também termina com uma aspa simples, depois de uma aspa escapada.

A leitura do problema pelo modelo está errada desde a etapa 2, e a falha de formato a esconde. Na etapa 2, o modelo escreve que format_quantity "descarta zeros à direita na parte fracionária, o que está correto" (palavras do modelo, da etapa 2 do replies.jsonl da gravação). O arquivo da etapa 3 mantém o erro: ele continua removendo zeros da fração com frac.rstrip("0"). Nenhuma chamada finish é analisada nesta execução, então esse arquivo nunca chega à verificação oculta. Uma sonda fora dos exemplos do livro executou o arquivo da etapa 3, copiado do seu bloco de código, em uma cópia do caso contra H-01, usando o pytest fixado 9.2.0:

FAILED test_t01.py::test_pads_to_two_places - AssertionError: assert '3.5 kg'...

A solução do próprio livro passa na mesma verificação. Portanto, a mudança proposta pelo modelo estava errada, e somente a falha de formato impediu que ela fosse verificada.

O exemplo afirma que a execução não foi considerada concluída, e que, a partir da terceira etapa, cada resposta traz seu arquivo entre aspas triplas dentro da chamada. A ferramenta de parada é a única ferramenta que carrega um arquivo inteiro, por isso a falha de formato está ali. O Capítulo 3 volta a essa ferramenta e muda a forma como uma alteração é enviada, o que elimina o arquivo entre aspas triplas, embora edições pequenas tragam problemas de aspas próprios. Ele não responde à leitura errada da etapa 2: uma alteração enviada na forma correta ainda pode estar errada.

Regra prática: Reproduza uma gravação sempre da mesma forma em cada execução, e nunca a edite para fazer uma execução passar. Uma gravação que falha mostra o que o modelo realmente fez. A correção pertence ao harness, ao prompt ou à escolha do modelo, e o resultado dessa correção é uma nova gravação.

O que dá errado, e o que é contado

A execução gravada de a execução reproduzida falha de duas maneiras. O loop captura a primeira e não a corrige: cada chamada malformada voltou como um resultado de erro que o modelo podia ler, e o orçamento de passos encerrou a execução. A segunda é a mudança errada. O loop nunca a vê, porque nenhuma chamada finish é interpretada e, por isso, nenhuma mudança é executada. Nessa gravação, o modelo nunca chamou uma ferramenta errada e nunca parou antes com uma resposta sem chamada. A falha de formato se repetiu até o orçamento acabar, e ela escondeu a leitura equivocada.

Quatro contagens descrevem toda execução deste livro. Passos contam chamadas ao modelo, e chamadas de ferramenta contam requests, inclusive as malformadas. As duas contagens de tokens são os prompt tokens, somados em todos os requests da execução, e os completion tokens que o modelo produziu. Os tokens são contados pelo tokenizador do próprio modelo fixado no momento em que a gravação é feita, e a contagem é armazenada no manifesto da gravação. A reprodução lê a contagem armazenada e não tokeniza de novo. Para a execução gravada, os prompt tokens são 13009 e os completion tokens são 2128. O total de prompt é alto porque cada passo envia de novo toda a transcrição.

Regra prática: Conte passos e chamadas de ferramenta do mesmo modo em toda execução, para que duas execuções possam ser comparadas. Quando uma execução termina no orçamento, leia suas linhas de erro antes de mudar o prompt ou o modelo. As linhas de erro mostram se o modelo está repetindo um mesmo erro, e isso indica qual parte do harness você deve examinar.

Decisões deste capítulo

  • As ferramentas rodam no próprio processo do harness, sobre uma cópia descartável. Isso basta para mostrar o ciclo, e não é uma defesa. Enquanto um sandbox não abrigar as ferramentas, a cópia é apenas um lugar onde as escritas vão parar.
  • A ferramenta de parada recebe o texto novo completo de um arquivo. Essa é a mudança mais simples que uma ferramenta de parada pode carregar, e é justamente a mudança que o modelo gravado não envia em uma forma que o analisador consegue ler. Uma ferramenta de parada diferente exigiria uma nova gravação.
  • O orçamento de passos é oito. O número é pequeno porque a tarefa deste capítulo precisa de cerca de quatro passos, e um orçamento compatível com a tarefa faz uma execução que se desvia se destacar.
  • A execução gravada é mostrada como aconteceu. A falha de formato e a interpretação equivocada permanecem no livro, porque uma gravação editada para passar mostraria um modelo que não existe. As respostas brutas do modelo gravado são mantidas ao lado das contagens, para que qualquer pessoa possa verificar o que o analisador fez de cada uma delas.

Regra prática: Antes de alterar qualquer uma dessas decisões, calcule o que a mudança faz com os números que este capítulo imprime. Um novo orçamento de passos muda as contagens de passos, uma nova ferramenta de parada exige uma nova gravação, e um sandbox muda o que as ferramentas conseguem alcançar. Faça a mudança nos termos do próprio capítulo em que ela ocorre, e execute novamente os exemplos roteirizados e gravados antes de confiar no resultado.

Este capítulo, nesta edição

Edição 2026.11.2Exemplos aprovados em 20 de nov de 20264 de 4 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.2.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 1 de 12: Dê a um modelo ferramentas e um laço

  1. O que o agente faz em uma tarefa
  2. Um laço em cerca de setenta linhas
  3. Duas ferramentas e uma ferramenta de parada
  4. Pare quando terminar, ou quando o orçamento acabar
  5. Execute em um modelo roteirizado
  6. Execute com o modelo gravado
  7. O que dá errado, e o que é contado
  8. Decisões deste capítulo

Voltar ao topoTodos os capítulos