Audiência: Engenheiros sênior
Formato: Opinião + padrões de arquitetura
Contexto: Equipes lean na LATAM
TL;DR
- Muitos sistemas de agentes estão super engenheirados
- Mais abstração ≠ mais valor
- Uma arquitetura simples baseada em pipes + ferramentas bem definidas costuma ser superior
O problema: muita mágica
Nos últimos 12 meses, os “AI agents” passaram de ser uma ideia interessante a se tornarem stacks complexos:
- Orquestradores
- Planejadores
- Memória vetorial
- Tool routers
- Loops recursivos
Tudo isso… até para resolver problemas relativamente simples.
Sinais claros de super engenharia
Se teu sistema tem isto, provavelmente estás sobreinstruindo:
- Mais de 3 camadas de abstração para executar uma tarefa
- Debugging difícil ou não determinístico
- Dependência excessiva de “autonomous loops”
- Prompts difíceis de versionarou testar
A alternativa: arquitetura simples
Em vez de agentes complexos, considera este padrão:
1. Entrada estruturada
{
"task": "generate_summary",
"input": "texto longo"
}
2. Router explícito
if (task === "generate_summary") {
return summarize(input);
}
3. Ferramentas determinísticas
Cada função faz uma única coisa bem:
async function summarize(text: string) {
return llm.call({
prompt: `Resuma isto: ${text}`
});
}
4. Sem loops desnecessários
Evita padrões como:
- “agent decides what to do next”
- execuções recursivas sem controle
Em seu lugar:
- fluxos lineares
- passos explícitos
Comparação direta
| Abordagem | Complexidade | Debugging | Controle | Custo |
|---|---|---|---|---|
| Agente complexo | Alta | Difícil | Baixo | Alto |
| Arquitetura simples | Baixa | Fácil | Alto | Baixo |
Quando SIM usar agentes?
Há casos em que os agentes fazem sentido:
- Tarefas abertas (research, exploration)
- Workflows não determinísticos
- Sistemas multi-step com alta variabilidade
Mas até lá:
Comece simples, adicione complexidade apenas se necessário
Perspectiva de equipes lean
Isso é relevante para qualquer equipe que busque se mover rápido sem sacrificar qualidade.
Realidade:
- Equipes que priorizam foco e clareza
- Necessidade de iterar rápido
- Busca de sistemas mantíveis
Implicação:
- Cada camada desnecessária adiciona fricção
- A simplicidade melhora velocidade, debugging e escalabilidade
Padrão recomendado
Em vez de “agent frameworks”, use:
- Funções explícitas
- Orquestração leve
- Logs claros
- Inputs/outputs bem definidos
Pense em:
“LLM as a function”
não em:
“LLM as an autonomous system”
Riscos de simplificar demais
- Perder flexibilidade em casos complexos
- Reescrever lógica se o sistema crescer
Mas na maioria dos casos:
É um trade-off correto
Veredicto
Os agentes não são o problema.
O problema é usá-los quando não precisa deles.
Reflexão final
A melhor arquitetura de IA hoje não é a mais sofisticada.
É a que tua equipe consegue:
- entender
- manter
- escalar
Sem fricção.