Sistemas Multi-Agente

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

O Que Você Vai Construir

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

                        ┌─────────────────────┐
       Consulta do Usuário  │                     │
      ────────────────▶ │    COORDENADOR      │
                        │  "Encaminhar para especialista"  │
                        └──────────┬──────────┘
                                   │
                   ┌───────────────┴───────────────┐
                   │                               │
                   ▼                               ▼
        ┌──────────────────┐            ┌──────────────────┐
        │  BILLING AGENT   │            │  SUPPORT AGENT   │
        │                  │            │                  │
        │  💰 Pagamentos   │            │  🔧 Problemas Técnicos  │
        │  📄 Faturas      │            │  🐛 Relatórios de Bug  │
        │  💳 Assinaturas  │            │  ❓ Como Fazer       │
        └──────────────────┘            └──────────────────┘

Conceitos Chave:

• Coordenador - Recebe todas as solicitações, decide quem as processa
• Especialistas - Agentes focados que se destacam em domínios específicos
• Transferência - Transição suave do coordenador para o especialista

---

Início Rápido

1. Crie Seu Projeto

cargo new multi_agent_demo
cd multi_agent_demo

Adicione dependências ao Cargo.toml:

[dependencies]
adk-rust = { version = "0.2", features = ["agents", "models", "cli"] }
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: Tenho uma pergunta sobre minha última fatura

[Agent: coordinator]
Assistant: Vou conectá-lo ao nosso especialista em faturamento para ajudar com sua pergunta sobre a fatura.

[Agent: billing_agent]
Assistant: Olá! Posso ajudá-lo com sua fatura. Qual pergunta específica você tem sobre sua última fatura?

You: Por que fui cobrado duas vezes?

[Agent: billing_agent]
Assistant: Entendo sua preocupação com a cobrança duplicada. Deixe-me ajudá-lo a investigar isso...

Como Funciona a Transferência Multi-Agent

A Visão Geral

Ao adicionar sub-agents a um Agent pai, o LLM ganha a capacidade de delegar tarefas:

                    ┌─────────────────────┐
    User Message    │                     │
   ─────────────────▶    COORDINATOR      │
                    │                     │
                    └──────────┬──────────┘
                               │
           "Esta é uma questão de cobrança..."
                               │
              ┌────────────────┴────────────────┐
              │                                 │
              ▼                                 ▼
   ┌──────────────────┐              ┌──────────────────┐
   │  billing_agent   │              │  support_agent   │
   │  💰 Payments     │              │  🔧 Tech Issues  │
   │  📄 Invoices     │              │  🐛 Bug Reports  │
   └──────────────────┘              └──────────────────┘

Fluxo de Transferência Passo a Passo

Veja exatamente o que acontece quando um usuário faz uma pergunta de cobrança:

┌──────────────────────────────────────────────────────────────────────┐
│ PASSO 1: Usuário envia mensagem                                      │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   Usuário: "Por que fui cobrado duas vezes na minha fatura?"         │
│                                                                      │
│                              ↓                                       │
│                                                                      │
│   ┌──────────────────────────────────────┐                          │
│   │         COORDINATOR AGENT            │                          │
│   │  Recebe a mensagem primeiro          │                          │
│   └──────────────────────────────────────┘                          │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ PASSO 2: LLM analisa e decide transferir                             │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   🧠 LLM pensa: "Isso é sobre uma cobrança de fatura..."             │
│                  "Fatura = tópico de cobrança..."                    │
│                  "Devo transferir para billing_agent"                │
│                                                                      │
│   📞 LLM calls: transfer_to_agent(agent_name="billing_agent")        │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ PASSO 3: Runner detecta a transferência e invoca o destino           │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌─────────┐     evento de transferência   ┌─────────────────┐     │
│   │ Runner  │ ─────────────────────▶      │  billing_agent  │     │
│   └─────────┘   (mesma mensagem do usuário) └─────────────────┘     │
│                                                                      │
│   • Runner encontra "billing_agent" na árvore de Agents              │
│   • Cria novo contexto com a MESMA mensagem do usuário               │
│   • Invoca billing_agent imediatamente                               │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘
                              ↓
┌──────────────────────────────────────────────────────────────────────┐
│ PASSO 4: Agent de destino responde                                   │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   ┌─────────────────────────────────────────┐                       │
│   │           billing_agent responde        │                       │
│   │                                         │                       │
│   │  "Posso ajudar com sua cobrança          │                       │
│   │   duplicada. Deixe-me investigar..."    │                       │
│   └─────────────────────────────────────────┘                       │
│                                                                      │
│   ✅ Usuário vê uma resposta contínua - sem interrupções!            │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

O Que Faz Funcionar

Antes vs Depois de Adicionar Sub-Agents

Sem sub-agents - Um Agent faz tudo:

User ──▶ coordinator ──▶ Response (lida com cobrança E suporte)

Com sub-agents - Especialistas cuidam de seu domínio:

User ──▶ coordinator ──▶ billing_agent ──▶ Response (especialista em cobrança)
                    ──▶ support_agent ──▶ Response (especialista em tecnologia)

---

Sistemas Multiagente Hierárquicos

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

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

                    ┌─────────────────────┐
                    │  PROJECT MANAGER    │  ← Nível 1: Coordenador de nível superior
                    │  "Gerenciar projetos" │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │  CONTENT CREATOR    │  ← Nível 2: Coordenador de nível intermediário  
                    │  "Coordenar P&E"    │
                    └──────────┬──────────┘
                               │
              ┌────────────────┴────────────────┐
              │                                 │
              ▼                                 ▼
   ┌──────────────────┐              ┌──────────────────┐
   │   RESEARCHER     │              │     WRITER       │  ← Nível 3: Especialistas
   │                  │              │                  │
   │  📚 Coletar fatos │              │  ✍️ Escrever conteúdo │
   │  🔍 Analisar dados │              │  📝 Polir texto  │
   │  📊 Encontrar fontes │              │  🎨 Estilo e tom │
   └──────────────────┘              └──────────────────┘

Como as Requisições Fluem

User: "Criar uma postagem de blog sobre veículos elétricos"
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  PROJECT MANAGER: "Esta é uma tarefa de conteúdo"           │
│  → transfere para content_creator                           │
└─────────────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  CONTENT CREATOR: "Preciso de pesquisa primeiro, depois escrita" │
│  → transfere para researcher                                │
└─────────────────────────────────────────────────────────────┘
                        │
                        ▼
┌─────────────────────────────────────────────────────────────┐
│  RESEARCHER: "Aqui está o que encontrei sobre VEs..."       │
│  → fornece um resumo da pesquisa                            │
└─────────────────────────────────────────────────────────────┘

Exemplo de Código 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:

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

Configuração de Sub-Agentes

Adicione sub-agentes a qualquer LlmAgent usando o método builder 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 agente pode ter múltiplos sub-agentes
• Sub-agentes podem ter seus próprios sub-agentes (hierarquias multi-nível)
• Os nomes dos Agentes devem ser únicos dentro da hierarquia
• As descrições ajudam o LLM a decidir para qual agente transferir

Escrevendo Instruções de Transferência Eficazes

Para transferências de agente bem-sucedidas, forneça instruções e descrições claras:

Instruções do Agente 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 de Sub-Agentes

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 agentes descritivos que indiquem claramente seu propósito
• Escreva descrições detalhadas - o LLM usa estas 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 agente pai
• Use terminologia consistente em todas as descrições dos agentes

Testando Seu Sistema Multi-Agente

Executando Exemplos

# Run the customer service example
cargo run --bin customer_service

# Run the hierarchical example  
cargo run --bin hierarchical

Exemplos de Prompts de Teste

Atendimento ao Cliente:

• "Tenho uma pergunta sobre minha última fatura" → Deve encaminhar para billing_agent
• "O aplicativo continua travando" → Deve encaminhar para support_agent
• "Como faço para atualizar meu plano?" → Deve encaminhar 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 → Content Creator → Writer
• "Pesquisar a história dos veículos elétricos" → PM → Content Creator → Researcher
• "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. Verifique os nomes dos agentes - Devem corresponder exatamente nas chamadas de transferência
2. Revise as descrições - Torne-as mais específicas e ricas em palavras-chave
3. Esclareça as instruções - Seja explícito sobre quando transferir
4. Teste casos extremos - Tente solicitações ambíguas para ver o comportamento de roteamento
5. Procure por indicadores de transferência - [Agent: name] mostra qual agente 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 Instrução do Agente

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

Ambas as instruções são incluídas no histórico da conversação, 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 instruções do 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 os valores do estado da sessão nos modelos de instrução.

Padrões Comuns de Múltiplos 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: Tenho uma pergunta sobre minha última fatura

[Agent: coordinator]
Assistant: Vou conectá-lo ao nosso especialista em faturamento.
🔄 [Transferência solicitada para: billing]

[Agent: billing]
Assistant: Olá! Posso ajudá-lo com sua fatura. Que pergunta específica você tem?

User: Por que fui cobrado duas vezes?

[Agent: billing]
Assistant: Deixe-me investigar essa cobrança duplicada para você...

Pontos Chave:

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

Decomposição Hierárquica de Tarefas

Hierarquias de vários níveis 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 multi-agentes 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 agente no estado da sessão, tornando-a disponível para agentes subsequentes.

Executando Sistemas Multiagente

Usando o Launcher

O Launcher oferece uma maneira fácil de executar e testar sistemas multiagente:

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 --example multi_agent -- chat

# Web server mode with UI
cargo run --example multi_agent -- serve
cargo run --example multi_agent -- serve --port 3000

Recursos:

• Indicadores de Agent: Mostra qual Agent está respondendo [Agent: coordinator]
• Visualização de Transferência: Exibe eventos de transferência 🔄 [Transfer requested to: billing_agent]
• Handoffs transparentes: O Agent alvo responde imediatamente após a transferência
• Histórico de Conversa: Mantém o contexto através das transferências de Agent

Testando Transferências

Para verificar se o seu sistema multiagente funciona corretamente:

1. Verifique se os nomes dos Agent aparecem entre colchetes quando eles respondem
2. Procure por indicadores de transferência (🔄) quando os Agent realizam handoff
3. Verifique respostas imediatas dos Agent alvo sem necessidade de nova solicitação
4. Teste diferentes tipos de solicitação para garantir o roteamento adequado
5. Verifique casos extremos como a transferência para Agent inexistentes

Depurando Problemas de Transferência

Se as transferências não estiverem funcionando:

• Verifique se os sub-Agent foram adicionados via .sub_agent()
• Verifique as descrições dos Agent - o LLM usa estas para decidir as transferências
• Revise as instructions - o pai deve mencionar quando transferir
• Verifique os nomes dos Agent - devem corresponder exatamente nas chamadas de transferência
• Habilite o 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 Agent descritivos para ajudar o LLM a tomar boas decisões de transferência
2. Instructions Específicas: Dê a cada Agent instructions claras e focadas em seu papel
3. Use Global Instruction: Defina personalidade e contexto consistentes para todos os Agent
4. Gerenciamento de State: Use output_key e variáveis de state para comunicação entre Agent
5. Limite a Profundidade da Hierarquia: Mantenha as hierarquias rasas (2-3 níveis) para melhor mantenibilidade
6. Teste a Lógica de Transferência: Verifique se os Agent transferem para os sub-Agent corretos para diferentes solicitações

Relacionado

• LLM Agent - Configuração central do Agent
• Workflow Agents - Agent Sequential, Parallel e Loop
• Sessions - Gerenciamento de state de Session

---

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