ARQUITETURA DE IA
Sistemas multiagentes e por que eles importam para produto de 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 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 único | Sistema multiagente | |
|---|---|---|
| Inteligência | Centralizada em um código | Distribuída entre os agentes |
| Falha | Cai o agente, para o sistema | Cai um agente, o sistema degrada e segue |
| Escala | Limitada pela máquina | Adiciona mais agentes |
| Comunicação | Entrada e saída de dados | Protocolo 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"
}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.