Sistemas Multi-Agente

Crie aplicações sofisticadas compondo agentes especializados em equipes.

Visão Geral da Hierarquia de Agentes

Rendering architecture…

O Que Você Irá Construir

Neste guia, você criará um Sistema de Atendimento ao Cliente onde um coordenador encaminha consultas para especialistas:

                        ┌─────────────────────┐
       User Query       │                     │
      ────────────────▶ │    COORDINATOR      │
                        │  "Route to expert"  │
                        └──────────┬──────────┘
                                   │
                   ┌───────────────┴───────────────┐
                   │                               │
                   ▼                               ▼
        ┌──────────────────┐            ┌──────────────────┐
        │  BILLING AGENT   │            │  SUPPORT AGENT   │
        │                  │            │                  │
        │  💰 Payments     │            │  🔧 Tech Issues  │
        │  📄 Invoices     │            │  🐛 Bug Reports  │
        │  💳 Subscriptions│            │  ❓ How-To       │
        └──────────────────┘            └──────────────────┘

Conceitos Chave:

• Coordinator - Recebe todas as solicitações, decide quem as processa
• Specialists - Agentes focados que se destacam em domínios específicos
• Transfer - Transição suave do coordinator para o specialist

---

Início Rápido

1. Crie Seu Projeto

cargo new multi_agent_demo
cd multi_agent_demo

Adicione dependências a Cargo.toml:

[dependencies]
adk-rust = "2.0.0"
tokio = { version = "1", features = ["full"] }
dotenvy = "0.15"

Crie .env com sua chave de API:

echo 'GOOGLE_API_KEY=your-api-key' > .env

2. Exemplo de Atendimento ao Cliente

Aqui está um exemplo completo e funcional:

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);

    // Specialist: Billing Agent
    let billing_agent = LlmAgentBuilder::new("billing_agent")
        .description("Handles billing questions: payments, invoices, subscriptions, refunds")
        .instruction("You are a billing specialist. Help customers with:\n\
                     - Invoice questions and payment history\n\
                     - Subscription plans and upgrades\n\
                     - Refund requests\n\
                     - Payment method updates\n\
                     Be professional and provide clear information about billing matters.")
        .model(model.clone())
        .build()?;

    // Specialist: Technical Support Agent
    let support_agent = LlmAgentBuilder::new("support_agent")
        .description("Handles technical support: bugs, errors, troubleshooting, how-to questions")
        .instruction("You are a technical support specialist. Help customers with:\n\
                     - Troubleshooting errors and bugs\n\
                     - How-to questions about using the product\n\
                     - Configuration and setup issues\n\
                     - Performance problems\n\
                     Be patient and provide step-by-step guidance.")
        .model(model.clone())
        .build()?;

    // Coordinator: Routes to appropriate specialist
    let coordinator = LlmAgentBuilder::new("coordinator")
        .description("Main customer service coordinator")
        .instruction("You are a customer service coordinator. Analyze each customer request:\n\n\
                     - For BILLING questions (payments, invoices, subscriptions, refunds):\n\
                       Transfer to billing_agent\n\n\
                     - For TECHNICAL questions (errors, bugs, how-to, troubleshooting):\n\
                       Transfer to support_agent\n\n\
                     - For GENERAL greetings or unclear requests:\n\
                       Respond yourself and ask clarifying questions\n\n\
                     When transferring, briefly acknowledge the customer and explain the handoff.")
        .model(model.clone())
        .sub_agent(Arc::new(billing_agent))
        .sub_agent(Arc::new(support_agent))
        .build()?;

    println!("🏢 Customer Service Center");
    println!("   Coordinator → Billing Agent | Support Agent");
    println!();

    Launcher::new(Arc::new(coordinator)).run().await?;
    Ok(())
}

Exemplo de Interação:

You: I have a question about my last invoice

[Agent: coordinator]
Assistant: I'll connect you with our billing specialist to help with your invoice question.

[Agent: billing_agent]
Assistant: Hello! I can help you with your invoice. What specific question do you have about your last invoice?

You: Why was I charged twice?

[Agent: billing_agent]
Assistant: I understand your concern about the duplicate charge. Let me help you investigate this...

Como a Transferência Multi-Agente Funciona

A Visão Geral

Quando você adiciona sub-agentes a um agente pai, o LLM ganha a capacidade de delegar tarefas:

                    ┌─────────────────────┐
    User Message    │                     │
   ─────────────────▶    COORDINATOR      │
                    │                     │
                    └──────────┬──────────┘
                               │
           "This is a billing question..."
                               │
              ┌────────────────┴────────────────┐
              │                                 │
              ▼                                 ▼
   ┌──────────────────┐              ┌──────────────────┐
   │  billing_agent   │              │  support_agent   │
   │  💰 Payments     │              │  🔧 Tech Issues  │
   │  📄 Invoices     │              │  🐛 Bug Reports  │
   └──────────────────┘              └──────────────────┘

Fluxo de Transferência Passo a Passo

Aqui está exatamente o que acontece quando um usuário faz uma pergunta sobre faturamento:

┌──────────────────────────────────────────────────────────────────────┐
│ STEP 1: User sends message                                           │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   User: "Why was I charged twice on my invoice?"                     │
│                                                                      │
│                              ↓                                       │
│                                                                      │
│   ┌──────────────────────────────────────┐                          │
│   │         COORDINATOR AGENT            │                          │
│   │  Receives message first              │                          │
│   └──────────────────────────────────────┘                          │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 2: LLM analyzes and decides to transfer                         │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   🧠 LLM thinks: "This is about an invoice charge..."                │
│                  "Invoice = billing topic..."                        │
│                  "I should transfer to billing_agent"                │
│                                                                      │
│   📞 LLM calls: transfer_to_agent(agent_name="billing_agent")        │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 3: Runner detects transfer and invokes target                   │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌─────────┐     transfer event      ┌─────────────────┐           │
│   │ Runner  │ ─────────────────────▶  │  billing_agent  │           │
│   └─────────┘   (same user message)   └─────────────────┘           │
│                                                                      │
│   • Runner finds "billing_agent" in agent tree                       │
│   • Creates new context with SAME user message                       │
│   • Invokes billing_agent immediately                                │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 4: Target agent responds                                        │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌─────────────────────────────────────────┐                       │
│   │           billing_agent responds        │                       │
│   │                                         │                       │
│   │  "I can help with your duplicate        │                       │
│   │   charge. Let me investigate..."        │                       │
│   └─────────────────────────────────────────┘                       │
│                                                                      │
│   ✅ User sees seamless response - no interruption!                  │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

O Que Faz Funcionar

Antes vs Depois de Adicionar Sub-Agentes

Sem sub-agentes - Um agente faz tudo:

User ──▶ coordinator ──▶ Response (handles billing AND support)

Com sub-agentes - Especialistas lidam com seu domínio:

User ──▶ coordinator ──▶ billing_agent ──▶ Response (billing expert)
                    ──▶ support_agent ──▶ Response (tech expert)

---

Sistemas Multi-Agente Hierárquicos

Para cenários complexos, você pode criar hierarquias multi-nível. Cada agente pode ter seus próprios sub-agentes, formando uma árvore:

Visual: Equipe de Conteúdo de 3 Níveis

                    ┌─────────────────────┐
                    │  PROJECT MANAGER    │  ← Level 1: Top-level coordinator
                    │  "Manage projects"  │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │  CONTENT CREATOR    │  ← Level 2: Mid-level coordinator  
                    │  "Coordinate R&W"   │
                    └──────────┬──────────┘
                               │
              ┌────────────────┴────────────────┐
              │                                 │
              ▼                                 ▼
   ┌──────────────────┐              ┌──────────────────┐
   │   RESEARCHER     │              │     WRITER       │  ← Level 3: Specialists
   │                  │              │                  │
   │  📚 Gather facts │              │  ✍️ Write content │
   │  🔍 Analyze data │              │  📝 Polish text  │
   │  📊 Find sources │              │  🎨 Style & tone │
   └──────────────────┘              └──────────────────┘

Como as Solicitações Descendem

User: "Create a blog post about electric vehicles"
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  PROJECT MANAGER: "This is a content task"                  │
│  → transfers to content_creator                             │
└─────────────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  CONTENT CREATOR: "Need research first, then writing"       │
│  → transfers to researcher                                  │
└─────────────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  RESEARCHER: "Here's what I found about EVs..."             │
│  → provides research summary                                │
└─────────────────────────────────────────────────────────────┘

Código de Exemplo Completo

use adk_rust::prelude::*;
use adk_rust::Launcher;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?);

    // Level 3: Leaf specialists
    let researcher = LlmAgentBuilder::new("researcher")
        .description("Researches topics and gathers comprehensive information")
        .instruction("You are a research specialist. When asked to research a topic:\n\
                     - Gather key facts and data\n\
                     - Identify main themes and subtopics\n\
                     - Note important sources or references\n\
                     Provide thorough, well-organized research summaries.")
        .model(model.clone())
        .build()?;

    let writer = LlmAgentBuilder::new("writer")
        .description("Writes polished content based on research")
        .instruction("You are a content writer. When asked to write:\n\
                     - Create engaging, clear content\n\
                     - Use appropriate tone for the audience\n\
                     - Structure content logically\n\
                     - Polish for grammar and style\n\
                     Produce professional, publication-ready content.")
        .model(model.clone())
        .build()?;

    // Level 2: Content coordinator
    let content_creator = LlmAgentBuilder::new("content_creator")
        .description("Coordinates content creation by delegating research and writing")
        .instruction("You are a content creation lead. For content requests:\n\n\
                     - If RESEARCH is needed: Transfer to researcher\n\
                     - If WRITING is needed: Transfer to writer\n\
                     - For PLANNING or overview: Handle yourself\n\n\
                     Coordinate between research and writing phases.")
        .model(model.clone())
        .sub_agent(Arc::new(researcher))
        .sub_agent(Arc::new(writer))
        .build()?;

    // Level 1: Top-level manager
    let project_manager = LlmAgentBuilder::new("project_manager")
        .description("Manages projects and coordinates with content team")
        .instruction("You are a project manager. For incoming requests:\n\n\
                     - For CONTENT creation tasks: Transfer to content_creator\n\
                     - For PROJECT STATUS or general questions: Handle yourself\n\n\
                     Keep track of overall project goals and deadlines.")
        .model(model.clone())
        .sub_agent(Arc::new(content_creator))
        .build()?;

    println!("📊 Hierarchical Multi-Agent System");
    println!();
    println!("   project_manager");
    println!("       └── content_creator");
    println!("               ├── researcher");
    println!("               └── writer");
    println!();

    Launcher::new(Arc::new(project_manager)).run().await?;
    Ok(())
}

Hierarquia de Agentes:

project_manager
└── content_creator
    ├── researcher
    └── writer

Exemplos de prompts:

• "Crie uma postagem de blog sobre IA na saúde" → PM → Content Creator → Writer
• "Pesquise veículos elétricos" → PM → Content Creator → Researcher

Configuração de Sub-Agentes

Adicione sub-agentes a qualquer LlmAgent usando o método construtor sub_agent():

let parent = LlmAgentBuilder::new("parent")
    .description("Coordinates specialized tasks")
    .instruction("Route requests to appropriate specialists.")
    .model(model.clone())
    .sub_agent(Arc::new(specialist_a))
    .sub_agent(Arc::new(specialist_b))
    .build()?;

Pontos Chave:

• Cada Agent pode ter múltiplos sub-agents
• Sub-agents podem ter seus próprios sub-agents (hierarquias multi-nível)
• Nomes de Agent devem ser únicos dentro da hierarquia
• Descrições ajudam o LLM a decidir para qual Agent transferir

Escrevendo Instruções de Transferência Eficazes

Instruções do Agent Pai

let coordinator = LlmAgentBuilder::new("coordinator")
    .description("Main customer service coordinator")
    .instruction("You are a customer service coordinator. Analyze each request:\n\n\
                 - For BILLING questions (payments, invoices, subscriptions):\n\
                   Transfer to billing_agent\n\n\
                 - For TECHNICAL questions (errors, bugs, troubleshooting):\n\
                   Transfer to support_agent\n\n\
                 - For GENERAL greetings or unclear requests:\n\
                   Respond yourself and ask clarifying questions")
    .model(model.clone())
    .sub_agent(Arc::new(billing_agent))
    .sub_agent(Arc::new(support_agent))
    .build()?;

Descrições dos Sub-Agents

let billing_agent = LlmAgentBuilder::new("billing_agent")
    .description("Handles billing questions: payments, invoices, subscriptions, refunds")
    .instruction("You are a billing specialist. Help with payment and subscription issues.")
    .model(model.clone())
    .build()?;

let support_agent = LlmAgentBuilder::new("support_agent")
    .description("Handles technical support: bugs, errors, troubleshooting, how-to questions")
    .instruction("You are a technical support specialist. Provide step-by-step guidance.")
    .model(model.clone())
    .build()?;

Melhores Práticas:

• Use nomes de Agent descritivos que indiquem claramente seu propósito
• Escreva descrições detalhadas - o LLM as usa para decidir as transferências
• Inclua palavras-chave específicas nas descrições que correspondam a prováveis solicitações do usuário
• Forneça regras de delegação claras nas instruções do Agent pai
• Use terminologia consistente nas descrições dos Agent

Testando Seu Sistema Multi-Agent

Executando Exemplos

cargo run --manifest-path examples/tier_examples/enterprise/Cargo.toml --bin 14-enterprise-multi-agent

Exemplos de Prompts de Teste

Atendimento ao Cliente:

• "Tenho uma pergunta sobre minha última fatura" → Deve ser encaminhado para billing_agent
• "O aplicativo continua travando" → Deve ser encaminhado para support_agent
• "Como faço para atualizar meu plano?" → Deve ser encaminhado para billing_agent
• "Olá, preciso de ajuda" → Deve permanecer com coordinator para esclarecimento

Hierárquico:

• "Criar uma postagem de blog sobre IA na saúde" → PM → Criador de Conteúdo → Redator
• "Pesquisar a história dos veículos elétricos" → PM → Criador de Conteúdo → Pesquisador
• "Qual é o status dos nossos projetos atuais?" → Deve permanecer com project_manager

Depurando Problemas de Transferência

Se as transferências não estiverem funcionando como esperado:

1. Verificar nomes de agents - Devem corresponder exatamente nas chamadas de transferência
2. Revisar descrições - Torná-las mais específicas e ricas em palavras-chave
3. Esclarecer instruções - Ser explícito sobre quando transferir
4. Testar casos de borda - Tentar requisições ambíguas para ver o comportamento de roteamento
5. Procurar indicadores de transferência - [Agent: name] mostra qual agent está respondendo

Instrução Global

Uso Básico

let agent = LlmAgentBuilder::new("assistant")
    .description("A helpful assistant")
    .global_instruction(
        "You are a professional assistant for Acme Corp. \
         Always maintain a friendly but professional tone. \
         Our company values are: customer-first, innovation, and integrity."
    )
    .instruction("Help users with their questions and tasks.")
    .model(model.clone())
    .build()?;

Instrução Global vs. Agent Instrução

• Instrução Global: Aplicada a todos os agents na hierarquia, define a personalidade/contexto geral
• Agent Instrução: Específica para cada agent, define seu papel e comportamento particulares

Ambas as instruções são incluídas no histórico da conversa, com a instrução global aparecendo primeiro.

Instruções Globais Dinâmicas

Para cenários mais avançados, você pode usar um provedor de instrução global que calcula a instrução dinamicamente:

use adk_core::GlobalInstructionProvider;

let provider: GlobalInstructionProvider = Arc::new(|ctx| {
    Box::pin(async move {
        // Access context information
        let user_id = ctx.user_id();
        
        // Compute dynamic instruction
        let instruction = format!(
            "You are assisting user {}. Tailor your responses to their preferences.",
            user_id
        );
        
        Ok(instruction)
    })
});

let agent = LlmAgentBuilder::new("assistant")
    .description("A personalized assistant")
    .global_instruction_provider(provider)
    .model(model.clone())
    .build()?;

Injeção de Variáveis de Estado

Tanto as instruções globais quanto as de agente suportam a injeção de variáveis de estado usando a sintaxe {variable}:

// Set state in a previous agent or tool
// state["company_name"] = "Acme Corp"
// state["user_role"] = "manager"

let agent = LlmAgentBuilder::new("assistant")
    .global_instruction(
        "You are an assistant for {company_name}. \
         The user is a {user_role}."
    )
    .instruction("Help with {user_role}-level tasks.")
    .model(model.clone())
    .build()?;

O framework injeta automaticamente valores do estado da sessão nos templates de instrução.

Padrões Comuns de Multi-Agentes

Padrão Coordenador/Despachante

Um agente central roteia requisições para sub-agentes especializados:

let billing = LlmAgentBuilder::new("billing")
    .description("Handles billing and payment questions")
    .model(model.clone())
    .build()?;

let support = LlmAgentBuilder::new("support")
    .description("Provides technical support")
    .model(model.clone())
    .build()?;

let coordinator = LlmAgentBuilder::new("coordinator")
    .instruction("Route requests to billing or support agents as appropriate.")
    .sub_agent(Arc::new(billing))
    .sub_agent(Arc::new(support))
    .model(model.clone())
    .build()?;

Exemplo de Conversa:

User: I have a question about my last invoice

[Agent: coordinator]
Assistant: I'll connect you with our billing specialist.
🔄 [Transfer requested to: billing]

[Agent: billing]
Assistant: Hello! I can help you with your invoice. 
What specific question do you have?

User: Why was I charged twice?

[Agent: billing]
Assistant: Let me investigate that duplicate charge for you...

Pontos Chave:

• O coordenador analisa a requisição e transfere para o agente de faturamento
• O agente de faturamento responde imediatamente na mesma rodada
• Mensagens subsequentes continuam com o agente de faturamento
• Indicadores de transferência (🔄) mostram quando as transferências ocorrem

Decomposição Hierárquica de Tarefas

Hierarquias multi-nível para decompor tarefas complexas:

// Low-level specialists
let researcher = LlmAgentBuilder::new("researcher")
    .description("Researches topics and gathers information")
    .model(model.clone())
    .build()?;

let writer = LlmAgentBuilder::new("writer")
    .description("Writes content based on research")
    .model(model.clone())
    .build()?;

// Mid-level coordinator
let content_creator = LlmAgentBuilder::new("content_creator")
    .description("Creates content by coordinating research and writing")
    .sub_agent(Arc::new(researcher))
    .sub_agent(Arc::new(writer))
    .model(model.clone())
    .build()?;

// Top-level manager
let project_manager = LlmAgentBuilder::new("project_manager")
    .description("Manages content creation projects")
    .sub_agent(Arc::new(content_creator))
    .model(model.clone())
    .build()?;

Combinando com Agentes de Fluxo de Trabalho

Sistemas multiagente funcionam bem com agentes de fluxo de trabalho (Sequential, Parallel, Loop):

use adk_agent::workflow::{SequentialAgent, ParallelAgent};

// Create specialized agents
let validator = LlmAgentBuilder::new("validator")
    .instruction("Validate the input data.")
    .output_key("validation_result")
    .model(model.clone())
    .build()?;

let processor = LlmAgentBuilder::new("processor")
    .instruction("Process data if {validation_result} is valid.")
    .output_key("processed_data")
    .model(model.clone())
    .build()?;

// Combine in a sequential workflow
let pipeline = SequentialAgent::new(
    "validation_pipeline",
    vec![Arc::new(validator), Arc::new(processor)]
);

// Use the pipeline as a sub-agent
let coordinator = LlmAgentBuilder::new("coordinator")
    .description("Coordinates data processing")
    .sub_agent(Arc::new(pipeline))
    .model(model.clone())
    .build()?;

Comunicação Entre Agentes

Agentes em uma hierarquia se comunicam através de um estado de sessão compartilhado:

// Agent A saves data to state
let agent_a = LlmAgentBuilder::new("agent_a")
    .instruction("Analyze the topic and save key points.")
    .output_key("key_points")  // Automatically saves output to state
    .model(model.clone())
    .build()?;

// Agent B reads data from state
let agent_b = LlmAgentBuilder::new("agent_b")
    .instruction("Expand on the key points: {key_points}")
    .model(model.clone())
    .build()?;

A configuração output_key salva automaticamente a resposta final de um agent no session state, tornando-a disponível para agentes subsequentes.

Encaminhamento de Estado e Artefatos do AgentTool

Ao usar AgentTool para encapsular agents como tools, as mudanças de estado e os artefatos dos sub-agents são automaticamente encaminhados para o contexto pai:

use adk_tool::AgentTool;

// Create a sub-agent that modifies state
let data_processor = LlmAgentBuilder::new("data_processor")
    .instruction("Process the data and save results.")
    .output_key("processed_data")
    .model(model.clone())
    .build()?;

// Wrap as a tool - state_delta and artifact_delta are forwarded
let processor_tool = AgentTool::new(Arc::new(data_processor));

// Parent agent can use the tool and see state changes
let coordinator = LlmAgentBuilder::new("coordinator")
    .instruction("Use the data_processor tool, then access {processed_data}.")
    .model(model.clone())
    .tool(Arc::new(processor_tool))
    .build()?;

O AgentTool executa sub-agents em modo não-streaming (StreamingMode::None) internamente, então o sub-agent acumula sua resposta completa antes de retorná-la ao pai. Isso evita problemas onde chunks de streaming parciais poderiam produzir resultados vazios.

Isso permite um fluxo de dados contínuo entre agentes pai e filho ao usar o padrão AgentTool.

Executando Sistemas Multi-Agente

Usando o Launcher

O Launcher fornece uma maneira fácil de executar e testar sistemas multi-agente:

use adk_rust::Launcher;

let coordinator = /* your multi-agent setup */;

Launcher::new(Arc::new(coordinator))
    .run()
    .await?;

Modos de Execução:

# Interactive console mode
cargo run --manifest-path examples/tier_examples/enterprise/Cargo.toml --bin 14-enterprise-multi-agent

# Use a generated API project when you need HTTP serving
cargo adk new multi_agent_api --template api

Recursos:

• Indicadores de Agente: Mostra qual agente está respondendo [Agent: coordinator]
• Visualização de Transferência: Exibe eventos de transferência 🔄 [Transfer requested to: billing_agent]
• Transferências Contínuas: O agente de destino responde imediatamente após a transferência
• Histórico de Conversa: Mantém o contexto entre as transferências de agente

Testando Transferências

Para verificar se o seu sistema multi-agente funciona corretamente:

1. Verifique se os nomes dos agentes aparecem entre colchetes quando eles respondem
2. Procure por indicadores de transferência (🔄) quando os agentes fazem a transferência
3. Verifique as respostas imediatas dos agentes de destino sem re-solicitar
4. Teste diferentes tipos de solicitação para garantir o roteamento adequado
5. Verifique casos extremos como a transferência para agentes não existentes

Depurando Problemas de Transferência

Se as transferências não estiverem funcionando:

• Verifique se os sub-agentes foram adicionados via .sub_agent()
• Verifique as descrições dos agentes - o LLM as usa para decidir as transferências
• Revise as instruções - o pai deve mencionar quando transferir
• Verifique os nomes dos agentes - devem corresponder exatamente nas chamadas de transferência
• Habilite o registro (logging) para ver as ações de transferência no fluxo de eventos

Melhores Práticas

1. Descrições Claras: Escreva nomes e descrições de agentes descritivos para ajudar o LLM a tomar boas decisões de transferência
2. Instruções Específicas: Dê a cada agente instruções claras e focadas para sua função
3. Use Instrução Global: Defina personalidade e contexto consistentes em todos os agentes
4. Gerenciamento de Estado: Use output_key e variáveis de estado para comunicação entre agentes
5. Limite a Profundidade da Hierarquia: Mantenha as hierarquias rasas (2-3 níveis) para melhor manutenibilidade
6. Teste a Lógica de Transferência: Verifique se os agentes transferem para os sub-agentes corretos para diferentes solicitações

Relacionado

• LLM Agent - Configuração central do agente
• Workflow Agents - Sequential, Parallel, and Loop agents
• Sessions - Gerenciamento de estado de sessão

---

Anterior: ← Workflow Agents | Próximo: Graph Agents →