O que é um agente de IA?

A palavra "agente" virou buzzword — mas o conceito técnico é preciso. Um agente de IA é um sistema que usa um modelo de linguagem como motor de raciocínio para tomar decisões iterativas, executar ferramentas externas e alcançar um objetivo que não é possível completar em um único passo de inferência.

A arquitetura canônica de um agente tem quatro componentes:

• LLM (o cérebro): decide o próximo passo com base no estado atual.
• Ferramentas (os braços): funções que o LLM pode invocar — busca na web, execução de código, APIs, banco de dados.
• Memória: curto prazo (contexto da conversa) e longo prazo (vetorial, banco de dados).
• Planejador: estratégia de como decompor o objetivo em subproblemas.

O padrão ReAct: raciocinar e agir em ciclos

Antes de qualquer framework, existe um padrão fundamental: ReAct (Reasoning + Acting), introduzido por Yao et al. no ICLR 2023 ^[1]. A ideia é deceptivamente simples: o modelo alterna entre duas etapas — Thought (o modelo "pensa em voz alta" sobre o que fazer) e Action (o modelo executa uma ferramenta e observa o resultado) — repetindo o ciclo até o objetivo ser alcançado.

"ReAct mostra que intercalar raciocínio e ação melhora dramaticamente a acurácia em tarefas de múltiplos passos em comparação com modelos que apenas raciocinam ou apenas agem."
— Yao et al., ICLR 2023

O ReAct é a base sobre a qual todos os frameworks modernos de agentes foram construídos. A diferença entre eles está em como gerenciam estado, múltiplos agentes e fluxos de controle complexos.

LangGraph: orquestração stateful com grafos

O LangGraph, da LangChain, foi lançado em 2024 como resposta a uma limitação clara dos pipelines de agente lineares: fluxos de trabalho reais raramente são lineares ^[2]. Em vez de uma cadeia de chamadas, o LangGraph modela o processo como um grafo de estado dirigido — cada nó é uma função (um LLM, uma ferramenta, uma validação) e as arestas definem transições condicionais.

Isso muda tudo. Com o LangGraph é possível:

• Criar loops de verificação: se o agente gera código com erro, o grafo o redireciona para uma etapa de correção antes de continuar.
• Implementar human-in-the-loop: pausar o fluxo e aguardar aprovação humana antes de executar ações irreversíveis (enviar e-mail, deletar registros).
• Manter estado persistente entre execuções — o agente pode retomar de onde parou.
• Executar nós em paralelo: pesquisar em múltiplas fontes simultaneamente.

CrewAI e AutoGen: quando um agente não é suficiente

Para problemas complexos, um único agente tem limitações de contexto e especialização. A solução é um sistema multi-agente: múltiplos LLMs com funções distintas colaborando em torno de um objetivo compartilhado.

O CrewAI organiza isso ao redor do conceito de "Crew" (equipe): cada agente tem um role (analista de dados, redator, revisor), um goal e um conjunto de ferramentas. A "tripulação" divide tarefas e produz um resultado colaborativo. Em benchmarks de escrita de relatórios e análise competitiva, equipes de 3–5 agentes especializados superam agentes únicos generalistas.

O AutoGen, da Microsoft Research, vai um nível acima: permite que agentes se comuniquem em conversas estruturadas, propondo e criticando soluções mutuamente ^[4]. O padrão AssistantAgent + UserProxyAgent — onde um agente gera código e outro o executa e valida — tornou-se uma das implementações mais replicadas da comunidade.

Model Context Protocol (MCP): o padrão aberto da Anthropic

Em novembro de 2024, a Anthropic abriu um protocolo que resolveu um problema silencioso mas crítico: como conectar agentes a ferramentas de forma padronizada e interoperável. O Model Context Protocol (MCP) define uma especificação aberta para que qualquer aplicação (banco de dados, API, sistema de arquivos) exponda suas capacidades para qualquer LLM via servidores MCP ^[3].

Pense no MCP como o "HTTP dos agentes": um contrato comum que elimina integrações personalizadas para cada par (modelo, ferramenta). Em menos de 6 meses do lançamento, a comunidade produziu mais de 2.000 servidores MCP para ferramentas como PostgreSQL, GitHub, Notion, Slack, Google Drive e Jira. Todos os principais IDEs (VS Code, JetBrains, Cursor) adotaram o protocolo.

Agent-to-Agent (A2A): o protocolo do Google

Se o MCP resolve a comunicação agente–ferramenta, o protocolo Agent2Agent (A2A), lançado pelo Google em 2025 ^[7], aborda a comunicação agente–agente. Em sistemas multi-agente distribuídos — onde agentes de diferentes empresas ou plataformas precisam colaborar — não havia padrão para descoberta, delegação de tarefas e troca de estado.

O A2A define uma "Agent Card" (manifesto JSON com capacidades e endpoint do agente), um mecanismo de delegação de tarefas e um modelo de autenticação. Junto com o MCP, ele completa a stack de interoperabilidade para sistemas agenticos corporativos.

Agentes em pipelines de dados: casos de uso reais

Os casos de uso mais maduros em produção hoje convergem em torno de tarefas onde o valor de automação é alto e o risco de erro é gerenciável:

• Engenharia de dados: agentes que recebem um requisito de negócio, geram transformações dbt, as testam e abrem um PR com documentação automática.
• Análise de dados: agentes de NL-to-SQL que aceitam perguntas em linguagem natural, geram queries, validam os resultados e geram relatórios estruturados.
• Code review automatizado: agentes que revisam PRs, sugerem melhorias de segurança e performance, e reportam violações de padrões.
• Monitoramento de incidentes: agentes que detectam anomalias em métricas, correlacionam logs, executam runbooks de diagnóstico e escalam para humanos com contexto completo.

Os desafios que ninguém conta na apresentação de produto

Depois do hype, a realidade de produção revela quatro problemas recorrentes que todo time enfrenta:

1. Alucinação de ações: o agente invoca ferramentas erradas ou argumentos inválidos. Mitigação: schemas de ferramentas bem definidos, validação de output e timeout rígido.

2. Explosão de custo: loops não terminados ou chamadas desnecessárias multiplicam tokens e APIs. Mitigação: limite de iterações, orçamento de custo por execução e observabilidade granular.

3. Falta de determinismo: o mesmo input pode produzir outputs diferentes, dificultando testes. Mitigação: temperatura 0 para etapas de decisão, testes baseados em propriedades (evals) em vez de comparação exata.

4. Segurança e prompt injection: agentes que processam dados externos são vulneráveis a instruções maliciosas injetadas no contexto. Mitigação: sandboxing de ferramentas, validação de inputs externos e permissões mínimas.

Observabilidade: você não pode gerenciar o que não enxerga

Agentes em produção sem observabilidade são caixas-pretas. As ferramentas mais adotadas hoje são o LangSmith (nativo do ecossistema LangChain) e o Langfuse (open-source, self-hostable). Ambas capturam o trace completo de cada execução: cada pensamento, cada chamada de ferramenta, cada token consumido e o custo associado.

Métricas essenciais para monitorar em produção: taxa de sucesso por objetivo, latência por etapa, custo médio por execução, taxa de erros por ferramenta e frequência de intervenção humana.

Como começar: da prova de conceito à produção

A trajetória mais eficiente que observamos em times de dados parte de casos simples e altamente observáveis:

1. Defina um objetivo delimitado com critério de sucesso binário (a tarefa foi concluída corretamente ou não).
2. Comece com zero agentes — resolva o problema com chains simples antes de adicionar loops e múltiplos agentes.
3. Adicione observabilidade antes de escalar — conecte LangSmith ou Langfuse desde o primeiro dia.
4. Implemente evals automatizados — avalie os outputs do agente com um conjunto de casos de teste antes de cada deploy.
5. Escale horizontalmente — replique o padrão que funcionou para novos domínios, não reescreva do zero.

What is an AI agent?

The word "agent" has become a buzzword — but the technical concept is precise. An AI agent is a system that uses a language model as a reasoning engine to make iterative decisions, execute external tools, and achieve a goal that cannot be completed in a single inference step.

The canonical agent architecture has four components:

• LLM (the brain): decides the next step based on current state.
• Tools (the arms): functions the LLM can invoke — web search, code execution, APIs, databases.
• Memory: short-term (conversation context) and long-term (vector, database).
• Planner: strategy for decomposing the goal into subproblems.

The ReAct pattern: reasoning and acting in cycles

Before any framework, there is a fundamental pattern: ReAct (Reasoning + Acting), introduced by Yao et al. at ICLR 2023 ^[1]. The idea is deceptively simple: the model alternates between two steps — Thought (the model "thinks out loud" about what to do) and Action (the model executes a tool and observes the result) — repeating the cycle until the goal is achieved.

"ReAct shows that interleaving reasoning and acting dramatically improves accuracy on multi-step tasks compared to models that only reason or only act."
— Yao et al., ICLR 2023

ReAct is the foundation on which all modern agent frameworks were built. The difference between them lies in how they manage state, multiple agents, and complex control flows.

LangGraph: stateful orchestration with graphs

LangGraph, from LangChain, was launched in 2024 as a response to a clear limitation of linear agent pipelines: real workflows are rarely linear ^[2]. Instead of a chain of calls, LangGraph models the process as a directed state graph — each node is a function (an LLM, a tool, a validation) and the edges define conditional transitions.

This changes everything. With LangGraph you can:

• Create verification loops: if the agent generates code with errors, the graph redirects it to a correction step before continuing.
• Implement human-in-the-loop: pause the flow and wait for human approval before executing irreversible actions (sending emails, deleting records).
• Maintain persistent state between executions — the agent can resume where it left off.
• Run nodes in parallel: search multiple sources simultaneously.

CrewAI and AutoGen: when one agent isn't enough

For complex problems, a single agent has context and specialization limits. The solution is a multi-agent system: multiple LLMs with distinct roles collaborating around a shared objective.

CrewAI organizes this around the "Crew" concept: each agent has a role (data analyst, writer, reviewer), a goal, and a set of tools. The "crew" divides tasks and produces a collaborative result. In report writing and competitive analysis benchmarks, teams of 3–5 specialized agents outperform single generalist agents.

AutoGen, from Microsoft Research, goes a level further: it allows agents to communicate in structured conversations, mutually proposing and critiquing solutions ^[4]. The AssistantAgent + UserProxyAgent pattern — where one agent generates code and another executes and validates it — has become one of the most replicated implementations in the community.

Model Context Protocol (MCP): Anthropic's open standard

In November 2024, Anthropic released a protocol that solved a silent but critical problem: how to connect agents to tools in a standardized and interoperable way. The Model Context Protocol (MCP) defines an open specification for any application (database, API, file system) to expose its capabilities to any LLM via MCP servers ^[3].

Think of MCP as the "HTTP of agents": a common contract that eliminates custom integrations for each (model, tool) pair. In less than 6 months after launch, the community produced over 2,000 MCP servers for tools like PostgreSQL, GitHub, Notion, Slack, Google Drive, and Jira. All major IDEs (VS Code, JetBrains, Cursor) adopted the protocol.

Agent-to-Agent (A2A): Google's protocol

If MCP solves agent–tool communication, the Agent2Agent (A2A) protocol, launched by Google in 2025 ^[7], addresses agent–agent communication. In distributed multi-agent systems — where agents from different companies or platforms need to collaborate — there was no standard for discovery, task delegation, and state exchange.

A2A defines an "Agent Card" (JSON manifest with agent capabilities and endpoint), a task delegation mechanism, and an authentication model. Together with MCP, it completes the interoperability stack for enterprise agentic systems.

Agents in data pipelines: real use cases

The most mature production use cases today converge around tasks where automation value is high and error risk is manageable:

• Data engineering: agents that receive a business requirement, generate dbt transformations, test them, and open a PR with automatic documentation.
• Data analysis: NL-to-SQL agents that accept natural language questions, generate queries, validate results, and generate structured reports.
• Automated code review: agents that review PRs, suggest security and performance improvements, and report standard violations.
• Incident monitoring: agents that detect metric anomalies, correlate logs, execute diagnostic runbooks, and escalate to humans with full context.

The challenges nobody mentions in the product demo

After the hype, production reality reveals four recurring problems every team faces:

1. Action hallucination: the agent invokes wrong tools or invalid arguments. Mitigation: well-defined tool schemas, output validation, and strict timeout.

2. Cost explosion: non-terminating loops or unnecessary calls multiply tokens and API costs. Mitigation: iteration limits, cost budget per execution, and granular observability.

3. Lack of determinism: the same input can produce different outputs, making testing difficult. Mitigation: temperature 0 for decision steps, property-based testing (evals) instead of exact comparison.

4. Security and prompt injection: agents that process external data are vulnerable to malicious instructions injected into context. Mitigation: tool sandboxing, external input validation, and least-privilege permissions.

Observability: you can't manage what you can't see

Production agents without observability are black boxes. The most widely adopted tools today are LangSmith (native to the LangChain ecosystem) and Langfuse (open-source, self-hostable). Both capture the full trace of each execution: every thought, every tool call, every token consumed, and the associated cost.

Essential metrics to monitor in production: success rate per goal, latency per step, average cost per execution, error rate per tool, and human intervention frequency.

How to start: from proof of concept to production

1. Define a bounded objective with a binary success criterion (the task was completed correctly or not).
2. Start with zero agents — solve the problem with simple chains before adding loops and multiple agents.
3. Add observability before scaling — connect LangSmith or Langfuse from day one.
4. Implement automated evals — evaluate agent outputs with a set of test cases before each deploy.
5. Scale horizontally — replicate the pattern that worked for new domains, don't rewrite from scratch.

¿Qué es un agente de IA?

La palabra "agente" se ha convertido en un buzzword — pero el concepto técnico es preciso. Un agente de IA es un sistema que usa un modelo de lenguaje como motor de razonamiento para tomar decisiones iterativas, ejecutar herramientas externas y alcanzar un objetivo que no se puede completar en un único paso de inferencia.

La arquitectura canónica de un agente tiene cuatro componentes:

• LLM (el cerebro): decide el siguiente paso según el estado actual.
• Herramientas (los brazos): funciones que el LLM puede invocar — búsqueda web, ejecución de código, APIs, bases de datos.
• Memoria: corto plazo (contexto de conversación) y largo plazo (vectorial, base de datos).
• Planificador: estrategia para descomponer el objetivo en subproblemas.

El patrón ReAct: razonar y actuar en ciclos

Antes de cualquier framework, existe un patrón fundamental: ReAct (Reasoning + Acting), introducido por Yao et al. en ICLR 2023 ^[1]. La idea es engañosamente simple: el modelo alterna entre dos pasos — Thought (el modelo "piensa en voz alta" sobre qué hacer) y Action (el modelo ejecuta una herramienta y observa el resultado) — repitiendo el ciclo hasta alcanzar el objetivo.

"ReAct muestra que intercalar razonamiento y acción mejora dramáticamente la precisión en tareas de múltiples pasos en comparación con modelos que solo razonan o solo actúan."
— Yao et al., ICLR 2023

LangGraph: orquestación stateful con grafos

LangGraph, de LangChain, fue lanzado en 2024 como respuesta a una limitación clara de los pipelines de agente lineales: los flujos de trabajo reales rara vez son lineales ^[2]. En lugar de una cadena de llamadas, LangGraph modela el proceso como un grafo de estado dirigido. Permite loops de verificación, human-in-the-loop, estado persistente entre ejecuciones y ejecución paralela de nodos.

CrewAI y AutoGen: cuando un agente no es suficiente

Para problemas complejos, un único agente tiene limitaciones de contexto y especialización. CrewAI organiza múltiples agentes en torno al concepto de "Crew": cada agente tiene un role, un goal y un conjunto de herramientas. AutoGen, de Microsoft Research, va un nivel más: permite que agentes se comuniquen en conversaciones estructuradas, proponiendo y criticando soluciones mutuamente ^[4].

Model Context Protocol (MCP): el estándar abierto de Anthropic

En noviembre de 2024, Anthropic lanzó el Model Context Protocol (MCP), un protocolo abierto que estandariza cómo cualquier aplicación expone sus capacidades a cualquier LLM ^[3]. Piensa en el MCP como el "HTTP de los agentes": un contrato común que elimina integraciones personalizadas para cada par (modelo, herramienta). En menos de 6 meses, la comunidad produjo más de 2.000 servidores MCP.

Agent-to-Agent (A2A): el protocolo de Google

El protocolo Agent2Agent (A2A), lanzado por Google en 2025 ^[7], aborda la comunicación agente–agente en sistemas multi-agente distribuidos. Define una "Agent Card" (manifiesto JSON con capacidades), un mecanismo de delegación de tareas y un modelo de autenticación. Junto con MCP, completa el stack de interoperabilidad para sistemas agénticos empresariales.

Desafíos reales en producción

Los cuatro problemas recurrentes que todo equipo enfrenta:

• Alucinación de acciones: el agente invoca herramientas incorrectas. Mitigación: schemas bien definidos y validación de output.
• Explosión de costos: loops no terminados multiplican tokens. Mitigación: límite de iteraciones y observabilidad granular.
• Falta de determinismo: mismo input, output diferente. Mitigación: temperatura 0 para decisiones y evals automatizados.
• Prompt injection: instrucciones maliciosas en datos externos. Mitigación: sandboxing y permisos mínimos.

Cómo empezar: de la prueba de concepto a la producción

1. Define un objetivo delimitado con criterio de éxito binario.
2. Comienza con cero agentes — resuelve el problema con chains simples primero.
3. Añade observabilidad antes de escalar — conecta LangSmith o Langfuse desde el primer día.
4. Implementa evals automatizados antes de cada deploy.
5. Escala horizontalmente — replica el patrón que funcionó, no reescribas desde cero.