ARQUITETURA DE IA

Sistemas multiagentes e por que eles importam para produto de IA

8 MIN · IA

Tenho estudado sistemas multiagentes na pós e cheguei a uma conclusão: para quem constrói produto de IA, essa não é mais uma arquitetura entre outras. É a forma de resolver problema que um agente sozinho não dá conta.

Nas aulas da pós, o assunto que mais tem aparecido é sistema multiagente. Demorei um pouco para entender por que ele ocupa tanto espaço, até perceber que o tema responde a uma pergunta bem prática: o que fazer quando o problema é grande demais para um único modelo resolver bem.

Engenharia de produto de IA é, no fundo, construir e melhorar produtos continuamente. E quanto mais eu estudo o assunto, mais vejo o sistema multiagente como peça fundamental nesse processo, porque ele é o que permite transformar um modelo genérico em algo que resolve um processo específico de ponta a ponta.

Primeiro, o que é um agente

Antes do sistema, a peça. Agente não é sinônimo de script nem de chamada de API. Na literatura da área, ele precisa ter quatro propriedades ao mesmo tempo:

  • Autonomia: decide sozinho o próximo passo, sem precisar de um comando humano a cada movimento.
  • Reatividade: percebe o ambiente e responde a mudanças nele.
  • Proatividade: não fica só esperando estímulo, toma iniciativa em direção a um objetivo.
  • Sociabilidade: conversa com outros agentes, e é essa que abre a porta para o sistema multiagente.

Na prática de software, um agente é um laço contínuo de perceber, decidir e agir. A estrutura mínima cabe em poucas linhas:

class Agente:
    def __init__(self, nome, objetivo):
        self.nome = nome
        self.objetivo = objetivo

    def perceber(self, ambiente):
        return ambiente.ler_dados()

    def decidir(self, percepcao):
        if percepcao["status"] == "urgente":
            return "acao_emergencial"
        return "planejar_proximo_passo"

    def agir(self, acao):
        return acao.executar()
O ciclo perceber, decidir e agir. O que muda de um agente para outro é o miolo do decidir.

O que muda quando são vários

Um sistema multiagente é um sistema descentralizado. Em vez de um cérebro central que sabe tudo e comanda tudo, cada agente carrega um pedaço da inteligência e da responsabilidade. A diferença não é de tamanho, é de arquitetura:

Agente únicoSistema multiagente
InteligênciaCentralizada em um códigoDistribuída entre os agentes
FalhaCai o agente, para o sistemaCai um agente, o sistema degrada e segue
EscalaLimitada pela máquinaAdiciona mais agentes
ComunicaçãoEntrada e saída de dadosProtocolo de mensagens entre pares

A linha da falha é a que mais me interessa como engenheiro. Sistema monolítico de IA tem um ponto único de quebra: se o prompt gigante confunde o modelo, tudo desanda junto. No sistema multiagente, o agente que falhou é substituído ou repetido, e o resto do fluxo continua de pé.

Como eles se coordenam

Aqui está a parte difícil, e é onde a teoria entra de verdade. Colocar vários agentes para rodar juntos é fácil. Garantir que eles não trabalhem uns contra os outros é o problema real, e ele é estudado formalmente pela teoria dos jogos.

A pergunta que a coordenação responde é se compensa mais cooperar ou competir. Quando a recompensa do conjunto é maior que a soma das recompensas individuais, cooperar é a estratégia racional. Quando não é, cada agente puxa para o seu lado e o sistema inteiro entrega menos do que entregaria com um agente só.

Para cooperar, eles precisam falar a mesma língua. O padrão clássico é a FIPA-ACL, que estrutura toda mensagem com a intenção declarada de forma explícita, e não escondida no meio do texto:

{
  "performative": "request",
  "sender": "Agente_Estoque",
  "receiver": "Agente_Logistica",
  "content": "Preciso de 10 unidades na prateleira A",
  "ontology": "estoque_varejo"
}
O campo performative separa pedir de informar e de aceitar. É o que evita ambiguidade entre agentes.

Por que isso importa para produto

Quando alguém pede um produto de IA, a tentação é escrever um prompt enorme que tenta dar conta de tudo. Funciona na demonstração e quebra no uso real, porque cada regra nova disputa espaço com as anteriores e o comportamento fica imprevisível.

A arquitetura multiagente resolve isso do mesmo jeito que a engenharia de processos resolve gargalo em uma linha de produção: separando responsabilidades. Cada agente tem um escopo estreito, um objetivo claro e um critério de sucesso próprio. Isso torna cada peça testável, substituível e melhorável em separado, que é exatamente o que um produto precisa para evoluir sem regredir.

Você não constrói um monólito que sabe tudo. Você monta um time de especialistas que sabem conversar.

Um exemplo real

O exemplo mais próximo de mim é o assistente de código que uso para desenvolver, incluindo este site. Ele funciona como sistema multiagente: um agente principal conduz a conversa e delega tarefas a subagentes especializados, cada um com contexto próprio e escopo limitado. Um pesquisa arquivos no projeto, outro revisa o código em busca de defeitos, outro executa e verifica o resultado.

As quatro propriedades aparecem todas ali. O subagente de busca decide sozinho onde procurar, reage ao que encontra, toma iniciativa para abrir arquivos que ninguém pediu e devolve o achado ao agente principal. Se ele falhar, o fluxo não morre: o agente principal recebe o erro e tenta outro caminho.

Fora do mundo de código, o padrão aparece em centros de distribuição automatizados, onde cada robô decide sua própria rota em vez de esperar ordem de um controlador único, e em plataformas de orquestração como CrewAI, LangGraph e n8n, que existem justamente para montar esses times de agentes sem escrever a coordenação do zero.

O que ainda estou estudando

Preciso ser honesto sobre o estágio em que estou: até aqui, isso é estudo de pós-graduação e leitura, não um sistema multiagente que eu tenha colocado em produção. O que já entendi da teoria não substitui a experiência de ver um time de agentes falhar de um jeito que ninguém previu.

As perguntas que ainda quero responder na prática são três: como medir se a divisão em agentes realmente melhorou o resultado, e não apenas a arquitetura; quanto custa em tempo e em chamadas de modelo manter vários agentes conversando; e como depurar um erro que só aparece na interação, quando cada agente isolado está funcionando corretamente.

O próximo passo é sair da teoria e montar um sistema pequeno, com três ou quatro agentes, sobre um processo que eu conheço bem. Quando isso acontecer, vira post aqui.

Sistemas multiagentesArquiteturaAI Product Engineering