Supervisores hierárquicos (orquestrador + trabalhadores)
Um supervisor planeja e delega; os trabalhadores executam e relatam os resultados — um padrão robusto para tarefas complexas.
Supervisores hierárquicos (orquestrador + trabalhadores) é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
O padrão do supervisor
Um agente "supervisor" decide o que fazer e delega tarefas a agentes "executores" especializados. Os agentes executores informam os resultados; o supervisor os sintetiza.
Esse padrão se aproxima mais do funcionamento de equipes humanas do que as conversas livres.
Estrutura
Dois níveis (às vezes mais):
- Supervisor — vê a consulta do usuário, divide-a em partes, escolhe os agentes executores e integra os resultados
- Agentes executores — agentes especializados (pesquisa, programação, matemática), cada um com suas próprias ferramentas e prompts
Por que uma hierarquia?
- Raciocínio mais claro — o supervisor vê o panorama geral
- Especialização — cada agente executor é pequeno e focado
- Mais fácil de avaliar — teste os agentes executores de forma independente
- Mais fácil adicionar novas capacidades — basta registrar um novo agente executor
LangGraph Implementation
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator
class State(TypedDict):
messages: Annotated[list, operator.add]
next: str
def supervisor(state):
# Ask LLM which worker should handle this
decision = supervisor_llm.invoke(state['messages']).content # 'researcher' / 'coder' / 'FINISH'
return {'next': decision}
def researcher(state):
result = research_agent.run(state['messages'][-1].content)
return {'messages': [{'role': 'tool', 'content': result}], 'next': 'supervisor'}
def coder(state):
result = code_agent.run(state['messages'][-1].content)
return {'messages': [{'role': 'tool', 'content': result}], 'next': 'supervisor'}Wiring the Graph
g = StateGraph(State)
g.add_node('supervisor', supervisor)
g.add_node('researcher', researcher)
g.add_node('coder', coder)
g.set_entry_point('supervisor')
g.add_conditional_edges(
'supervisor',
lambda s: s['next'],
{'researcher': 'researcher', 'coder': 'coder', 'FINISH': END}
)
g.add_edge('researcher', 'supervisor')
g.add_edge('coder', 'supervisor')
app = g.compile()Independência dos agentes executores
Cada agente executor é um miniagente autocontido. Crie e teste cada um isoladamente; componha-os sob o supervisor.
Conjuntos de ferramentas dos agentes executores
Limite cada agente a ONLY as ferramentas de que precisa:
- Pesquisador — search, fetch
- Programador — read_file, write_file, run_python
- Banco de dados — list_tables, run_sql
Descrições de ferramentas mais claras; menos confusão.
Formato de comunicação
Os agentes executores retornam resumos estruturados ao supervisor — não transcrições completas. Isso economiza tokens e facilita a integração pelo supervisor:
class WorkerResult(BaseModel):
summary: str
citations: list[str]
next_step_suggestion: str = ''Encerramento
O supervisor decide quando parar. Normalmente:
- Confiança acima do limite
- Sinal de tarefa concluída vindo de um agente executor
- Contador de etapas ultrapassado
Hierarquias de vários níveis
Para tarefas muito complexas, adicione uma terceira camada: um supervisor "líder de equipe" para engenharia, outro para pesquisa e assim por diante. Cada um delega tarefas a agentes executores de sua área.
Perfil de custos
Cada decisão do supervisor é uma chamada de LLM. Cada agente executor tem seu próprio ciclo. O custo total é aproximadamente N_supervisor_decisions × cost_per_decision + N_worker_loops × cost_per_loop.
Quando usar
- Tarefas complexas com subdomínios claros
- Tarefas que precisam de estilos de prompting diferentes em cada etapa
- Sistemas nos quais você deseja adicionar capacidades gradualmente
Antipadrões
- O supervisor realiza todo o trabalho de fato — isso anula o propósito
- Os agentes executores chamam outros agentes executores sem o conhecimento do supervisor — perde-se o controle
- Agentes executores demais (>10) — a seleção do supervisor se torna pouco confiável
Função do supervisor
Qual é a principal tarefa do supervisor neste padrão?
Recapitulação
Supervisor + agentes executores > um único agente grande. Cada agente executor é pequeno, focado e testável de forma independente. O supervisor decide quem trabalha em quê.
Aprenda AI Agents com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 60
- Aulas
- 239
Perguntas Frequentes
A aula “Supervisores hierárquicos (orquestrador + trabalhadores)” é grátis?
Sim — o texto completo de “Supervisores hierárquicos (orquestrador + trabalhadores)” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.
O que vou aprender em “Supervisores hierárquicos (orquestrador + trabalhadores)”?
Um supervisor planeja e delega; os trabalhadores executam e relatam os resultados — um padrão robusto para tarefas complexas. Você pratica AI Agents com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Agents?
Nenhuma experiência prévia é necessária. AI Agents no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Supervisores hierárquicos (orquestrador + trabalhadores)”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Agents?
Sim. Cada aula de AI Agents inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Multiagentes baseados em conversa (AutoGen)
- Supervisores hierárquicos (orquestrador + trabalhadores)
- Papéis e especializações dos agentes
- Protocolos de comunicação (barramentos de mensagens)