Sistemas Multi-Agentes de IA: Guia Prático com LangGraph e CrewAI em Python

Introdução: Por Que Sistemas Multi-Agentes Dominam a IA em 2026

Se você trabalha com IA há algum tempo, já percebeu o padrão: primeiro vieram os modelos de linguagem isolados, depois os agentes únicos com acesso a ferramentas, e agora — em 2026 — entramos de vez na era dos sistemas multi-agentes. A ideia é quase óbvia quando você para pra pensar: em vez de sobrecarregar um único agente com dezenas de ferramentas e responsabilidades, você monta uma equipe de agentes especializados que colaboram entre si.

E os números deixam isso bem claro.

Segundo a Gartner, as consultas sobre sistemas multi-agentes cresceram 1.445% entre o primeiro trimestre de 2024 e o segundo trimestre de 2025. A Deloitte projeta que o mercado de agentes autônomos de IA pode atingir US$ 8,5 bilhões em 2026 e até US$ 45 bilhões até 2030. E a previsão é que 40% das aplicações empresariais já incluam agentes de IA específicos para tarefas até o final deste ano — contra menos de 5% em 2025. Honestamente, esses números surpreenderam até quem já acompanhava a tendência de perto.

Se você já leu nossos guias sobre Function Calling e Tool Use em Agentes de IA e Pipelines RAG em Produção, este artigo é o próximo passo natural. O function calling ensina um agente a usar ferramentas individuais, o RAG ensina a buscar informações relevantes, e os sistemas multi-agentes ensinam múltiplos agentes a coordenar, delegar e colaborar — como uma equipe de trabalho real.

Neste guia, vamos construir sistemas multi-agentes completos usando os dois frameworks que dominam o cenário em 2026: LangGraph (controle granular baseado em grafos) e CrewAI (equipes baseadas em papéis). Ao final, você vai ter código funcional, padrões de arquitetura prontos pra produção e uma visão clara de quando usar cada abordagem.

O Que São Sistemas Multi-Agentes e Por Que Usá-los

Um sistema multi-agente (ou MAS — Multi-Agent System) é uma arquitetura onde múltiplos agentes de IA autônomos trabalham juntos pra resolver tarefas que seriam complexas ou ineficientes demais para um agente único. Cada agente tem seu próprio prompt de sistema, conjunto de ferramentas, modelo LLM (que pode ser diferente dos outros) e especialização.

Pense numa analogia simples: você não pediria para uma única pessoa fazer pesquisa de mercado, escrever código, revisar qualidade e criar documentação ao mesmo tempo. Pelo menos não se quisesse um resultado bom. Em vez disso, você monta uma equipe com especialistas. Sistemas multi-agentes seguem exatamente essa lógica.

Vantagens Concretas Sobre Agentes Únicos

• Especialização: Cada agente domina um domínio específico, o que reduz alucinações e melhora a precisão das respostas.
• Escalabilidade: Novos agentes podem ser adicionados sem reescrever o sistema inteiro — basta "contratar" mais um pra equipe.
• Paralelismo: Agentes independentes podem trabalhar simultaneamente em subtarefas diferentes, acelerando o resultado final.
• Revisão cruzada: Um agente pode validar o trabalho de outro, o que aumenta bastante a confiabilidade.
• Economia de tokens: Cada agente recebe apenas o contexto que precisa, em vez de receber tudo (e isso faz diferença no custo).

Padrões de Arquitetura Multi-Agente

Existem três padrões principais de coordenação entre agentes. Vale entender cada um antes de decidir qual se encaixa no seu caso:

1. Rede com Supervisor (Hub-and-Spoke): Um agente orquestrador decide qual agente especializado deve atuar em cada etapa. É o padrão mais comum e, sinceramente, o mais fácil de debugar.
2. Rede Colaborativa (Peer-to-Peer): Agentes se comunicam diretamente entre si sem um supervisor central. Mais flexível, mas mais difícil de controlar — o que pode ser um problema em produção.
3. Hierárquico: Múltiplas camadas de supervisores coordenam sub-equipes de agentes. Ideal para sistemas empresariais complexos onde você precisa de delegação em vários níveis.

PADRÃO 1: SUPERVISOR (Hub-and-Spoke)
=====================================
            ┌─────────────┐
            │  Supervisor  │
            └──────┬──────┘
         ┌─────────┼─────────┐
         ▼         ▼         ▼
   ┌──────────┐ ┌──────────┐ ┌──────────┐
   │Pesquisador│ │ Redator  │ │ Revisor  │
   └──────────┘ └──────────┘ └──────────┘

PADRÃO 2: REDE COLABORATIVA
=====================================
   ┌──────────┐     ┌──────────┐
   │ Agente A │◄───►│ Agente B │
   └────┬─────┘     └────┬─────┘
        │                 │
        ▼                 ▼
   ┌──────────┐     ┌──────────┐
   │ Agente C │◄───►│ Agente D │
   └──────────┘     └──────────┘

PADRÃO 3: HIERÁRQUICO
=====================================
            ┌────────────────┐
            │ Supervisor Geral│
            └───────┬────────┘
         ┌──────────┴──────────┐
    ┌────▼─────┐         ┌────▼─────┐
    │ Líder    │         │ Líder    │
    │ Equipe A │         │ Equipe B │
    └────┬─────┘         └────┬─────┘
    ┌────┴────┐         ┌────┴────┐
    ▼         ▼         ▼         ▼
 Agente 1  Agente 2  Agente 3  Agente 4

LangGraph: Controle Total com Grafos Direcionados

O LangGraph, desenvolvido pela equipe do LangChain, é provavelmente o framework mais poderoso e flexível pra construir sistemas multi-agentes em 2026. Com o lançamento da versão 1.0 em outubro de 2025 e a evolução para a série 1.1.x, o LangGraph atingiu uma maturidade real de produção. Ele representa seus workflows como grafos direcionados, onde cada nó é um agente ou ação, e cada aresta define o fluxo de execução.

O grande diferencial? Controle granular. Você define exatamente o estado compartilhado, as transições, as condições de roteamento e os pontos de interrupção. Isso torna o sistema transparente, auditável e depurável — três coisas que quem já colocou IA em produção sabe que fazem toda a diferença.

Conceitos Fundamentais do LangGraph

• State (Estado): Uma estrutura de dados compartilhada entre todos os nós. Geralmente definida com TypedDict ou BaseModel do Pydantic.
• Nodes (Nós): Funções Python que recebem o estado, executam uma operação (como chamar um LLM ou ferramenta) e retornam atualizações ao estado.
• Edges (Arestas): Conexões entre nós — podem ser diretas (incondicionais) ou condicionais, baseadas em lógica que você controla.
• Checkpointing: Persistência automática do estado em cada etapa, o que permite retomar execuções interrompidas sem perder progresso.

Instalação e Configuração

pip install langgraph langchain-openai langchain-anthropic langchain-community tavily-python

Exemplo Prático: Sistema Multi-Agente com Supervisor

Bom, vamos ao que interessa. Aqui vamos construir um sistema completo com três agentes especializados — um pesquisador, um analista e um redator — coordenados por um supervisor que decide quem atua em cada etapa.

import os
import json
from typing import Literal, TypedDict, Annotated
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.messages import HumanMessage, SystemMessage, BaseMessage
from langgraph.graph import StateGraph, START, END, MessagesState
from langgraph.prebuilt import create_react_agent
from langgraph.types import Command

# Configuração
os.environ["OPENAI_API_KEY"] = "sua-chave-openai"
os.environ["TAVILY_API_KEY"] = "sua-chave-tavily"

llm = ChatOpenAI(model="gpt-4o", temperature=0)

# === FERRAMENTAS ===
ferramenta_pesquisa = TavilySearchResults(max_results=5)

# === AGENTES ESPECIALIZADOS ===

# 1. Agente Pesquisador
agente_pesquisador = create_react_agent(
    llm,
    tools=[ferramenta_pesquisa],
    prompt=(
        "Você é um pesquisador especializado. Sua função é buscar "
        "informações atualizadas e relevantes sobre o tema solicitado. "
        "Retorne os dados de forma estruturada com fontes."
    )
)

# 2. Agente Analista (sem ferramentas, apenas raciocínio)
agente_analista = create_react_agent(
    llm,
    tools=[],
    prompt=(
        "Você é um analista de dados. Sua função é analisar informações "
        "brutas, identificar padrões, extrair insights relevantes e "
        "apresentar conclusões fundamentadas."
    )
)

# 3. Agente Redator
agente_redator = create_react_agent(
    llm,
    tools=[],
    prompt=(
        "Você é um redator técnico. Sua função é transformar análises "
        "e dados em textos claros, bem estruturados e informativos. "
        "Use linguagem acessível e profissional."
    )
)

# === NÓS DO GRAFO ===
def no_pesquisador(state: MessagesState) -> Command:
    """Executa o agente pesquisador e retorna ao supervisor."""
    resultado = agente_pesquisador.invoke(state)
    return Command(
        update={
            "messages": [
                HumanMessage(
                    content=resultado["messages"][-1].content,
                    name="pesquisador"
                )
            ]
        },
        goto="supervisor"
    )

def no_analista(state: MessagesState) -> Command:
    """Executa o agente analista e retorna ao supervisor."""
    resultado = agente_analista.invoke(state)
    return Command(
        update={
            "messages": [
                HumanMessage(
                    content=resultado["messages"][-1].content,
                    name="analista"
                )
            ]
        },
        goto="supervisor"
    )

def no_redator(state: MessagesState) -> Command:
    """Executa o agente redator e retorna ao supervisor."""
    resultado = agente_redator.invoke(state)
    return Command(
        update={
            "messages": [
                HumanMessage(
                    content=resultado["messages"][-1].content,
                    name="redator"
                )
            ]
        },
        goto="supervisor"
    )

# === SUPERVISOR ===
membros = ["pesquisador", "analista", "redator"]

prompt_supervisor = (
    "Você é o supervisor de uma equipe de agentes especializados: "
    f"{membros}. Dada a tarefa do usuário, determine qual agente deve "
    "atuar a seguir, ou se a tarefa já foi concluída. "
    "Fluxo típico: pesquisador → analista → redator → FINISH. "
    "Responda com o nome do próximo agente ou FINISH."
)

def no_supervisor(state: MessagesState) -> Command:
    """Decide qual agente deve atuar a seguir."""
    mensagens = [
        SystemMessage(content=prompt_supervisor)
    ] + state["messages"]

    resposta = llm.invoke(mensagens)
    proximo = resposta.content.strip()

    if "FINISH" in proximo.upper():
        return Command(goto=END)

    # Roteia para o agente escolhido
    destinos = {
        "pesquisador": "pesquisador",
        "analista": "analista",
        "redator": "redator"
    }

    for nome, no in destinos.items():
        if nome in proximo.lower():
            return Command(goto=no)

    return Command(goto=END)

# === CONSTRUÇÃO DO GRAFO ===
grafo = StateGraph(MessagesState)

# Adicionar nós
grafo.add_node("supervisor", no_supervisor)
grafo.add_node("pesquisador", no_pesquisador)
grafo.add_node("analista", no_analista)
grafo.add_node("redator", no_redator)

# O fluxo começa pelo supervisor
grafo.add_edge(START, "supervisor")

# Compilar o grafo
app = grafo.compile()

# === EXECUÇÃO ===
resultado = app.invoke({
    "messages": [
        HumanMessage(
            content="Analise as tendências de IA generativa em 2026 "
                    "e crie um resumo executivo."
        )
    ]
})

# A última mensagem contém o resultado final
print(resultado["messages"][-1].content)

Esse exemplo demonstra o padrão de supervisor mais comum: o orquestrador recebe a tarefa, delega ao pesquisador, recebe os dados, delega ao analista, recebe a análise, delega ao redator e finaliza. Cada agente só vê o contexto que precisa — nada mais, nada menos.

Adicionando Memória e Persistência

Pra sistemas de produção, memória persistente é praticamente obrigatória — especialmente pra workflows longos que podem ser interrompidos no meio do caminho. O LangGraph oferece checkpointing nativo, e configurar é bem direto:

from langgraph.checkpoint.memory import MemorySaver

# Criar checkpointer (em memória para desenvolvimento)
checkpointer = MemorySaver()

# Compilar com persistência
app = grafo.compile(checkpointer=checkpointer)

# Executar com thread_id para rastreabilidade
config = {"configurable": {"thread_id": "sessao-001"}}
resultado = app.invoke(
    {"messages": [HumanMessage(content="Sua tarefa aqui")]},
    config=config
)

# Retomar a mesma sessão mais tarde
resultado_continuacao = app.invoke(
    {"messages": [HumanMessage(content="Mais detalhes, por favor.")]},
    config=config  # Mesmo thread_id preserva o histórico
)

Um detalhe importante: pra produção real, substitua o MemorySaver por um checkpointer persistente como PostgreSQL ou Redis. O MemorySaver funciona bem pra desenvolvimento e testes, mas os dados se perdem quando o servidor reinicia.

CrewAI: Equipes de Agentes Baseadas em Papéis

Enquanto o LangGraph te dá controle de baixo nível (que é ótimo, mas exige mais trabalho), o CrewAI adota uma abordagem bem diferente. A ideia é inspirada em estruturas organizacionais do mundo real: você define agentes com papéis, objetivos e até "histórias de fundo" — como se estivesse literalmente montando uma equipe. O framework cuida da delegação, comunicação e gerenciamento de estado por baixo dos panos.

O CrewAI evoluiu muito em 2026. Hoje tem suporte nativo a Agent-to-Agent (A2A), integração com GPT-4.1, Gemini 2.5 Pro e Claude, e uma comunidade com mais de 100.000 desenvolvedores certificados na plataforma. Não dá mais pra ignorar.

Instalação

pip install crewai crewai-tools

Exemplo Prático: Equipe de Pesquisa e Conteúdo

Vamos criar uma equipe com três agentes — pesquisador, analista e redator — usando o CrewAI. Se você acabou de ver o exemplo do LangGraph, vale comparar as abordagens lado a lado pra sentir a diferença no nível de abstração.

import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

os.environ["OPENAI_API_KEY"] = "sua-chave-openai"
os.environ["SERPER_API_KEY"] = "sua-chave-serper"

# === FERRAMENTAS ===
ferramenta_busca = SerperDevTool()

# === DEFINIÇÃO DOS AGENTES ===
pesquisador = Agent(
    role="Pesquisador Sênior de Tecnologia",
    goal=(
        "Encontrar informações atualizadas e confiáveis sobre "
        "o tema solicitado, priorizando fontes primárias e dados "
        "quantitativos."
    ),
    backstory=(
        "Você é um pesquisador veterano com 15 anos de experiência "
        "em análise de tendências tecnológicas. É conhecido por sua "
        "capacidade de separar hype de realidade e encontrar dados "
        "que outros ignoram."
    ),
    tools=[ferramenta_busca],
    verbose=True,
    allow_delegation=False
)

analista = Agent(
    role="Analista de Dados e Tendências",
    goal=(
        "Analisar os dados coletados, identificar padrões e insights "
        "relevantes, e formular conclusões fundamentadas."
    ),
    backstory=(
        "Você é um analista de dados com formação em estatística e "
        "experiência em consultoria estratégica. Seu diferencial é "
        "transformar dados brutos em narrativas claras e acionáveis."
    ),
    verbose=True,
    allow_delegation=False
)

redator = Agent(
    role="Redator Técnico Especializado",
    goal=(
        "Transformar análises técnicas em conteúdo claro, bem "
        "estruturado e envolvente para um público profissional."
    ),
    backstory=(
        "Você é um redator técnico premiado que combina profundidade "
        "técnica com clareza de comunicação. Seus textos são referência "
        "no setor de tecnologia."
    ),
    verbose=True,
    allow_delegation=False
)

# === DEFINIÇÃO DAS TAREFAS ===
tarefa_pesquisa = Task(
    description=(
        "Pesquise as principais tendências em IA generativa para 2026. "
        "Foque em: adoção empresarial, frameworks dominantes, casos de "
        "uso emergentes e dados de mercado. Inclua pelo menos 5 fontes."
    ),
    expected_output=(
        "Relatório estruturado com dados quantitativos, tendências "
        "identificadas e lista de fontes consultadas."
    ),
    agent=pesquisador
)

tarefa_analise = Task(
    description=(
        "Com base nos dados da pesquisa, analise as tendências "
        "identificadas. Compare com o cenário de 2025, identifique "
        "mudanças significativas e avalie impactos para empresas."
    ),
    expected_output=(
        "Análise aprofundada com insights acionáveis, comparações "
        "temporais e recomendações para tomadores de decisão."
    ),
    agent=analista,
    context=[tarefa_pesquisa]  # Depende da pesquisa
)

tarefa_redacao = Task(
    description=(
        "Crie um resumo executivo com base na análise. O texto deve "
        "ter entre 500 e 800 palavras, usar linguagem profissional "
        "e incluir as principais conclusões e recomendações."
    ),
    expected_output=(
        "Resumo executivo formatado, pronto para distribuição, "
        "com título, subtítulos e conclusão."
    ),
    agent=redator,
    context=[tarefa_analise]  # Depende da análise
)

# === MONTAGEM DA CREW ===
equipe = Crew(
    agents=[pesquisador, analista, redator],
    tasks=[tarefa_pesquisa, tarefa_analise, tarefa_redacao],
    process=Process.sequential,  # Execução sequencial
    verbose=True
)

# === EXECUÇÃO ===
resultado = equipe.kickoff()
print(resultado)

Percebeu a diferença? A abordagem do CrewAI é muito mais declarativa: você define o que cada agente faz e em que ordem, e o framework cuida do como. Pra prototipagem rápida e equipes que pensam naturalmente em termos de papéis e responsabilidades, isso é uma mão na roda.

Execução Hierárquica com Gerente Automático

O CrewAI também suporta um modo hierárquico bem interessante, onde um agente "gerente" é criado automaticamente pra coordenar a equipe:

from crewai import Crew, Process

equipe_hierarquica = Crew(
    agents=[pesquisador, analista, redator],
    tasks=[tarefa_pesquisa, tarefa_analise, tarefa_redacao],
    process=Process.hierarchical,  # Gerente automático
    manager_llm="gpt-4o",
    verbose=True
)

resultado = equipe_hierarquica.kickoff()

No modo hierárquico, o gerente decide dinamicamente a ordem de execução e pode reatribuir tarefas se julgar necessário. Na prática, ele simula o comportamento de um líder de equipe real — e funciona surpreendentemente bem pra tarefas que não têm uma ordem óbvia de execução.

LangGraph vs. CrewAI: Quando Usar Cada Um

Essa é provavelmente a pergunta que mais recebo. A escolha entre LangGraph e CrewAI depende do seu caso de uso, do nível de controle que você precisa e da maturidade da sua equipe. Aqui vai uma comparação direta:

Critério	LangGraph	CrewAI
Nível de controle	Granular (baixo nível)	Alto nível (declarativo)
Curva de aprendizado	Mais íngreme	Mais suave
Fluxos condicionais	Nativo e flexível	Limitado ao sequencial/hierárquico
Persistência de estado	Checkpointing nativo	Gerenciado internamente
Consumo de tokens	~2.000 tokens/tarefa	~3.500 tokens/tarefa
Depuração	Visualização do grafo	Logs verbose
Melhor para	Produção, compliance, fluxos complexos	Prototipagem rápida, equipes com papéis claros

Use LangGraph quando: você precisa de controle total sobre o fluxo de execução, opera em setores regulados que exigem auditoria, ou tem workflows altamente condicionais. O LangGraph também é a escolha certa quando a eficiência de tokens importa — e em produção com volume, ela sempre importa.

Use CrewAI quando: você quer montar uma equipe de agentes rapidamente, pensa naturalmente em termos de papéis e responsabilidades, ou está prototipando algo que vai ser refinado depois. A abordagem declarativa do CrewAI permite ir do conceito ao protótipo funcional em questão de horas.

Combine ambos quando: sistemas maduros frequentemente usam LangGraph pra orquestração de alto nível e CrewAI pra sub-equipes específicas. Na minha experiência, essa abordagem híbrida tende a oferecer o melhor dos dois mundos — controle onde é necessário e praticidade onde é possível.

Padrões Avançados para Produção

Construir um sistema multi-agente que funciona no ambiente de desenvolvimento é uma coisa. Colocá-lo em produção com confiabilidade é outra completamente diferente. Aqui vão os padrões que separam protótipos de sistemas reais.

1. Human-in-the-Loop (Humano no Ciclo)

Pra decisões críticas — como aprovar transações, enviar e-mails ou modificar dados em produção — você precisa de pontos de interrupção onde um humano valida antes do agente prosseguir. Ignorar isso é receita pra desastre.

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.types import interrupt, Command

def no_aprovacao(state: MessagesState):
    """Ponto de interrupção para aprovação humana."""
    ultima_mensagem = state["messages"][-1].content

    # Interrompe e aguarda aprovação
    aprovacao = interrupt({
        "acao_proposta": ultima_mensagem,
        "mensagem": "Deseja aprovar esta ação? (sim/nao)"
    })

    if aprovacao.get("resposta") == "sim":
        return Command(goto="executar")
    else:
        return Command(goto=END)

2. Tratamento de Erros e Fallbacks

Agentes falham. APIs dão timeout. LLMs alucinam. Isso não é exceção — é a regra. Um sistema de produção precisa lidar com tudo isso sem quebrar:

import time
from langchain_core.messages import HumanMessage

def no_agente_resiliente(state: MessagesState) -> Command:
    """Agente com retry e fallback."""
    max_tentativas = 3

    for tentativa in range(max_tentativas):
        try:
            resultado = agente.invoke(state)
            conteudo = resultado["messages"][-1].content

            # Validação básica: resposta não pode estar vazia
            if not conteudo or len(conteudo.strip()) < 10:
                raise ValueError("Resposta insuficiente do agente")

            return Command(
                update={
                    "messages": [
                        HumanMessage(content=conteudo, name="agente")
                    ]
                },
                goto="supervisor"
            )

        except Exception as e:
            if tentativa < max_tentativas - 1:
                time.sleep(2 ** tentativa)  # Backoff exponencial
                continue
            else:
                # Fallback: informar o supervisor sobre a falha
                return Command(
                    update={
                        "messages": [
                            HumanMessage(
                                content=f"ERRO: Agente falhou após "
                                        f"{max_tentativas} tentativas. "
                                        f"Erro: {str(e)}",
                                name="agente"
                            )
                        ]
                    },
                    goto="supervisor"
                )

3. Limitação de Loops e Custo

Um dos riscos mais comuns (e mais caros) em sistemas multi-agentes é o loop infinito — agentes que ficam delegando tarefas entre si sem nunca convergir pra uma resposta. Já vi isso acontecer em produção e a conta de API não perdoa. Implemente sempre um limite de iterações:

from typing import TypedDict, Annotated
from langgraph.graph import add_messages

class EstadoComLimite(TypedDict):
    messages: Annotated[list, add_messages]
    iteracoes: int
    max_iteracoes: int

def no_supervisor_com_limite(state: EstadoComLimite) -> Command:
    """Supervisor com proteção contra loops infinitos."""
    iteracao_atual = state.get("iteracoes", 0) + 1
    max_iter = state.get("max_iteracoes", 10)

    if iteracao_atual > max_iter:
        return Command(
            update={
                "messages": [
                    HumanMessage(
                        content="Limite de iterações atingido. "
                                "Finalizando com o melhor resultado "
                                "disponível.",
                        name="supervisor"
                    )
                ],
                "iteracoes": iteracao_atual
            },
            goto=END
        )

    # Lógica normal do supervisor...
    return Command(
        update={"iteracoes": iteracao_atual},
        goto="proximo_agente"
    )

4. Observabilidade com LangSmith

Em produção, você precisa saber exatamente o que cada agente fez, quanto custou e onde o sistema falhou. Sem isso, debugar problemas vira adivinhação. O LangSmith se integra nativamente com o LangGraph pra fornecer essa visibilidade:

# Configurar LangSmith para rastreamento
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "sua-chave-langsmith"
os.environ["LANGCHAIN_PROJECT"] = "meu-sistema-multi-agente"

# A partir daqui, todas as execuções do LangGraph são
# automaticamente rastreadas no LangSmith com:
# - Tempo de execução por agente
# - Tokens consumidos por chamada
# - Entradas e saídas de cada nó
# - Custo total da execução

Caso de Uso Real: Assistente de Análise Financeira

Pra mostrar como tudo se conecta na prática, vamos construir algo mais palpável: um assistente que analisa ações da bolsa usando múltiplos agentes especializados com o CrewAI. Esse é o tipo de sistema que realmente economiza horas de trabalho manual.

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool

# Ferramentas
busca = SerperDevTool()
scraper = ScrapeWebsiteTool()

# === AGENTES ESPECIALIZADOS ===
coletor_dados = Agent(
    role="Coletor de Dados Financeiros",
    goal="Coletar dados atualizados sobre a empresa ou ativo solicitado",
    backstory=(
        "Especialista em coleta de dados financeiros com acesso a "
        "múltiplas fontes. Prioriza dados oficiais e relatórios "
        "recentes de analistas."
    ),
    tools=[busca, scraper],
    allow_delegation=False
)

analista_fundamentalista = Agent(
    role="Analista Fundamentalista",
    goal=(
        "Avaliar a saúde financeira da empresa com base em "
        "indicadores fundamentalistas"
    ),
    backstory=(
        "Analista CFA com 20 anos de experiência em mercados "
        "emergentes. Especialista em identificar empresas "
        "subvalorizadas com fundamentos sólidos."
    ),
    allow_delegation=False
)

analista_risco = Agent(
    role="Analista de Risco",
    goal="Avaliar riscos associados ao investimento e cenários adversos",
    backstory=(
        "Especialista em gestão de risco com foco em mercados "
        "voláteis. Conhecido por identificar riscos que outros "
        "analistas ignoram."
    ),
    allow_delegation=False
)

redator_relatorio = Agent(
    role="Redator de Relatórios de Investimento",
    goal=(
        "Consolidar análises em um relatório de investimento "
        "profissional e acionável"
    ),
    backstory=(
        "Redator financeiro com experiência em bancos de investimento. "
        "Seus relatórios são claros, objetivos e orientados à ação."
    ),
    allow_delegation=False
)

# === TAREFAS ===
coleta = Task(
    description=(
        "Colete dados financeiros recentes sobre {empresa}: "
        "receita, lucro, margens, dívida, crescimento, múltiplos "
        "(P/L, P/VP, EV/EBITDA) e notícias relevantes dos últimos "
        "30 dias."
    ),
    expected_output="Dados financeiros estruturados com fontes",
    agent=coletor_dados
)

analise_fundamental = Task(
    description=(
        "Analise os dados coletados e avalie: saúde financeira, "
        "vantagens competitivas, qualidade da gestão, perspectivas "
        "de crescimento e valuation relativo ao setor."
    ),
    expected_output=(
        "Análise fundamentalista com recomendação (Comprar, "
        "Manter ou Vender) e preço-alvo estimado"
    ),
    agent=analista_fundamentalista,
    context=[coleta]
)

analise_risco_tarefa = Task(
    description=(
        "Avalie os principais riscos: exposição cambial, risco "
        "regulatório, concentração de receita, alavancagem, "
        "riscos macroeconômicos e setoriais."
    ),
    expected_output=(
        "Matriz de riscos com classificação de severidade e "
        "probabilidade, e estratégias de mitigação"
    ),
    agent=analista_risco,
    context=[coleta, analise_fundamental]
)

relatorio_final = Task(
    description=(
        "Consolide todas as análises em um relatório profissional "
        "de investimento com: resumo executivo, análise fundamental, "
        "análise de riscos, recomendação final e disclaimer."
    ),
    expected_output=(
        "Relatório de investimento completo e formatado, pronto "
        "para distribuição para clientes"
    ),
    agent=redator_relatorio,
    context=[analise_fundamental, analise_risco_tarefa]
)

# === EXECUÇÃO ===
equipe_financeira = Crew(
    agents=[
        coletor_dados, analista_fundamentalista,
        analista_risco, redator_relatorio
    ],
    tasks=[coleta, analise_fundamental, analise_risco_tarefa, relatorio_final],
    process=Process.sequential,
    verbose=True
)

resultado = equipe_financeira.kickoff(
    inputs={"empresa": "Petrobras (PETR4)"}
)
print(resultado)

Esse é o tipo de aplicação que realmente mostra o valor dos sistemas multi-agentes. Automatizar a produção de relatórios de investimento que normalmente levariam horas de trabalho manual — e com uma qualidade surpreendentemente boa. A estrutura modular facilita bastante quando você precisa adicionar novos agentes (como um analista técnico ou especialista em ESG) sem mexer no que já funciona.

Boas Práticas para Sistemas Multi-Agentes

Depois de construir e colocar em produção alguns sistemas multi-agentes, certos padrões se destacam de forma bem consistente. Vou listar os que considero mais importantes:

1. Comece com poucos agentes: 2 a 4 agentes resolvem a maioria dos casos. Sério. Cada agente adicional aumenta a complexidade de coordenação de um jeito que nem sempre é óbvio no início.
2. Prompts claros e específicos: Cada agente precisa de um prompt de sistema que defina com clareza seu papel, suas limitações e o formato esperado de saída. Ambiguidade no prompt sempre — sempre — gera resultados imprevisíveis.
3. Limite iterações explicitamente: Defina um número máximo de voltas no loop supervisor-agente. Sem esse limite, a conta de API pode virar uma surpresa bem desagradável.
4. Valide saídas entre agentes: Não confie cegamente na saída de um agente antes de passá-la ao próximo. Validações básicas de formato e conteúdo salvam muita dor de cabeça.
5. Use modelos diferentes por agente: Nem todo agente precisa do modelo mais caro. Agentes de roteamento funcionam perfeitamente com GPT-4o-mini, enquanto agentes de análise complexa se beneficiam de GPT-4o ou Claude Opus.
6. Monitore custos desde o dia um: Com múltiplos agentes fazendo múltiplas chamadas, os custos escalam rápido. Implemente tracking de tokens logo no início — depois fica mais difícil de adicionar.
7. Teste com entradas adversárias: Alimente o sistema com perguntas ambíguas, fora do escopo e até mal-intencionadas. Você vai se surpreender com o que aparece quando os agentes recebem inputs inesperados.

Perguntas Frequentes

Qual a diferença entre um agente de IA e um sistema multi-agente?

Um agente de IA é uma entidade única que percebe seu ambiente, toma decisões e executa ações de forma autônoma — geralmente usando um LLM com acesso a ferramentas. Um sistema multi-agente vai além: coordena múltiplos agentes especializados que colaboram entre si. Pense na diferença entre um profissional freelancer e uma equipe organizada — ambos produzem resultados, mas a equipe consegue lidar com problemas mais complexos através da especialização.

Preciso de sistemas multi-agentes ou um agente único resolve meu problema?

Na maioria dos casos simples, um agente único com boas ferramentas dá conta. Sistemas multi-agentes fazem mais sentido quando: (1) a tarefa envolve domínios distintos que pedem especialização, (2) você precisa de paralelismo real, (3) o número de ferramentas é grande demais pra um único agente gerenciar com eficiência (acima de 15-20 ferramentas), ou (4) você quer revisão cruzada entre etapas pra aumentar a confiabilidade.

Quanto custa rodar um sistema multi-agente em produção?

Depende bastante do número de agentes, do modelo usado e da complexidade da tarefa. Em benchmarks, o LangGraph consome cerca de 2.000 tokens por tarefa, o CrewAI cerca de 3.500 e o AutoGen pode chegar a 8.000 — por causa do overhead conversacional. Pra ter uma ideia prática: um sistema com 3-4 agentes usando GPT-4o processando 100 tarefas por dia pode custar entre US$ 5 e US$ 30/dia. Usar modelos menores como GPT-4o-mini pra agentes de roteamento ajuda bastante a otimizar esse custo.

LangGraph e CrewAI podem ser usados juntos?

Sim, e essa combinação tá ficando cada vez mais comum em sistemas maduros. A ideia é usar o LangGraph como orquestrador de alto nível — controlando o fluxo geral, condições de parada e persistência — enquanto sub-equipes específicas rodam com CrewAI pela facilidade na definição de papéis. Funciona bem na prática.

Quais são os riscos de segurança em sistemas multi-agentes?

Os principais riscos incluem: (1) prompt injection em cadeia, onde uma entrada maliciosa se propaga entre agentes, (2) escalação de privilégios, onde um agente menos restrito acessa ferramentas de um agente privilegiado, (3) loop infinito ou consumo descontrolado de recursos, e (4) vazamento de dados sensíveis entre contextos de agentes. Pra mitigar, implemente validação de entrada em cada agente, isolamento de ferramentas, limites de iteração e monitoramento de custos em tempo real. Não é opcional — é requisito.