Verificando acesso...

TRILHA 4

🛠️ Tools, Agentes e Multi-Agente

Tool/function calling provider-neutral, agentes single (ReAct), padrões multi-agente e MCP.

2
Módulos GA
1
Beta
~3h
Duração
18
Tópicos

🎯 Objetivo desta trilha

Agentes que chamam ferramentas com sandbox e tracing — não brinquedos de demo.

🔍 O que você vai explorar

  • Tool/function calling provider-neutral via JSON Schema.
  • Description é o prompt do tool; escolha do modelo depende dela.
  • Sandbox jailed obrigatório (filesystem, rede, processo).
  • ReAct e planner/executor; controle de loop (max_iter, budget).
  • Tracing por step (OpenTelemetry GenAI semconv).
  • Multi-agente: orquestrador-trabalhador, debate, MCP.

👤 Para quem

Quem vai colocar agente em produção. T6 vai exigir P5 baseado em T4.

📚 Módulos da trilha

4.1 GA
~65 min · Intermediário · Hands-on

🛠️ Tool/function calling provider-neutral

Como o modelo invoca funções estruturadas. JSON Schema como contrato, tratamento de erro, sandbox obrigatório.

1 📋 JSON Schema: o contrato do tool
O que é: Cada tool tem schema declarativo: nome, descrição, parâmetros tipados (string, number, enum, etc.) com required.
Por que aprender: Schema bom = chamada confiável. Modelo usa descrição para escolher e schema para formatar argumentos.
Conceitos-chave: JSON Schema 2020-12, parameter validation, required fields, oneOf.
2 ✏️ Descrição do tool: o prompt do prompt
O que é: Texto livre que descreve quando usar o tool. É lido pelo LLM ao decidir ferramenta.
Por que aprender: Modelos escolhem tool com base na descrição. 'busca_web' vs 'busca_web_para_eventos_recentes_e_notícias' muda comportamento.
Conceitos-chave: Tool description, disambiguation, when-to-use clauses.
3 🚦 Erro tipado: sucesso, retry, abort
O que é: Resultado do tool inclui campo de status. Modelo lê e decide retry, fallback ou parar.
Por que aprender: Sem tipo de erro, modelo tenta de novo cegamente ou desiste. Estrutura permite recovery inteligente.
Conceitos-chave: Result types, ToolError, retry-able vs fatal, exponential backoff.
4 🔒 Sandbox obrigatório (PLAN item 62a)
O que é: Toda tool que toca FS/rede/processo roda dentro de FilesystemSandbox + NetworkPolicy do fec_sdk.
Por que aprender: Prompt injection consegue fazer tool ler ~/.aws/credentials se não houver sandbox. PLAN item 62a é gate de GA.
Conceitos-chave: Path traversal, deny-by-default, allowlist, jail.
5 🔄 Loop: tool → resultado → próximo passo
O que é: Modelo decide chamar tool → executa → resultado vira mensagem do role 'tool' → modelo continua.
Por que aprender: Esse é o building block de agentes. Um loop simples já resolve muitas tarefas.
Conceitos-chave: Tool result message, role=tool, tool_use_id, conversation continuation.
6 🎚️ Tool choice: forçar ou deixar o modelo decidir
O que é: Parâmetro que controla quando o modelo pode chamar tool: auto (decide), any (deve chamar algum), specific (deve chamar X).
Por que aprender: Em alguns fluxos você QUER forçar uso de tool (ex.: extract). Em outros, deixar livre é melhor.
Conceitos-chave: tool_choice, parallel tool calls, required tool.
Ver Completo →
4.2 GA
~70 min · Avançado · Hands-on

🤖 Agentes single: ReAct e planner/executor

Agente é loop tool→pensa→tool. ReAct, planner/executor, controle de loop, e como debugar via tracing.

1 🧭 ReAct: Reason + Act
O que é: Loop: modelo pensa em texto livre ('Pensamento: preciso buscar X') → decide tool ('Ação: search(X)') → recebe resultado ('Observação: ...') → repete.
Por que aprender: Padrão simples e eficaz. Pensamento explícito facilita debug e melhora qualidade em tarefas multi-passo.
Conceitos-chave: ReAct (Yao 2022), Thought-Action-Observation, scratchpad, reasoning trace.
2 📐 Planner / Executor: separar plano de execução
O que é: Primeiro passo: LLM gera plano em N passos. Segundo passo: executor segue passo por passo.
Por que aprender: Para tarefas estruturadas conhecidas (workflows), plano explícito é mais auditável que ReAct.
Conceitos-chave: Plan-and-execute, BabyAGI, hierarchical planning.
3 ⛔ Controle de loop: max_iterations, max_tokens
O que é: Agente tem budget explícito: máximo de iterações, máximo de tokens, timeout total.
Por que aprender: Sem isso, agente loopa em produção e queima orçamento. Limite duro é seguro.
Conceitos-chave: Max iterations, token budget, wall-clock timeout, infinite loop detection.
4 🔍 Tracing por step: a chave para debug
O que é: Cada step do agente vira entry estruturada (timestamp, tool, args, result, next). Salvo em traces/.
Por que aprender: Sem tracing, debugar agente em produção é impossível. P2 do curso exige.
Conceitos-chave: Step trace, OpenTelemetry, structured logging, step replay.
5 🛡️ Recovery: tool error, JSON inválido, loop
O que é: Estratégias para quando algo dá errado: retry com fix, abort com mensagem, fallback para LLM puro.
Por que aprender: Em produção, ferramentas falham, JSON vem malformado, modelos respondem fora do schema. Sem recovery, agente quebra.
Conceitos-chave: Retry policies, JSON repair, graceful degradation, partial success.
6 💸 Orçamento de custo por agente
O que é: Antes de iniciar o agente, declarar 'esta tarefa custa no máximo X tokens / Y dólares'. Aborta se atingir.
Por que aprender: Cap nativo de provedor é última linha; cap explícito no agente é controle real.
Conceitos-chave: Per-task budget, cost estimation, soft limit, hard limit.
Ver Completo →
4.3 beta
~70 min · Avançado · Avançado

👥 Multi-agente e MCP (beta)

Padrões multi-agente: orquestrador-trabalhador, debate, blackboard. MCP (Model Context Protocol). Quando NÃO multiplicar.

1 🎼 Orquestrador + trabalhadores especializados
O que é: Um agente coordenador delega sub-tarefas a agentes especializados (busca, código, análise). Cada um tem tools próprios.
Por que aprender: Especialização por contexto: cada trabalhador tem prompt e tools focados. Orquestrador foca em planejamento.
Conceitos-chave: Orchestrator-worker, specialization, hand-off, delegation.
2 💬 Debate: dois agentes argumentam
O que é: Dois agentes resolvem a mesma tarefa, comparam respostas, debatem discordâncias até convergir.
Por que aprender: Em raciocínio adversarial, debate consistente bate single agent. Custo: 2-3× mais tokens.
Conceitos-chave: Multi-agent debate, adversarial reasoning, consensus protocol.
3 🗂️ Blackboard: estado compartilhado
O que é: Agentes leem e escrevem em um 'quadro' compartilhado. Comunicação assíncrona via state, não messaging direto.
Por que aprender: Para workflows longos onde agentes trabalham em paralelo em sub-tarefas, blackboard é mais escalável que conversation.
Conceitos-chave: Blackboard architecture, shared state, async coordination.
4 🔌 MCP: Model Context Protocol
O que é: Protocolo aberto para conectar LLMs a fontes de dados e tools externos. Inspirado em LSP do mundo de IDE.
Por que aprender: Padroniza integração: um servidor MCP serve tools/resources que qualquer cliente pode consumir.
Conceitos-chave: MCP, tools, resources, prompts, transport (stdio, SSE).
5 🤝 Handoff: passar contexto entre agentes
O que é: Quando agente A passa para B, sumariza o estado relevante. Não passar histórico inteiro = economia + atenção.
Por que aprender: Histórico cresce; contexto cresce; lost-in-the-middle entra em jogo. Handoff explícito mitiga.
Conceitos-chave: Context compression, state handoff, summary message.
6 🚫 Quando UM agente é melhor
O que é: Tarefas que cabem em um único contexto coerente, sem trabalho paralelizável real, são piores com multi-agente.
Por que aprender: Multi-agente adiciona: handoff loss, custo extra, complexidade de tracing. Default ao single agent é honesto.
Conceitos-chave: Default to simple, complexity budget, when-not-to.
Ver Completo →

🔬 Bibliografia da trilha

Referências datadas, congeladas na release. Lista completa em bibliografia/T4.md.

Bibliografia T4 →

🗺️ Outras trilhas