Agent frameworks

Agent framework é o esqueleto que segura o loop do agente: estado, plano, ferramentas e o que acontece entre cada chamada ao modelo. Sem framework, o agente vira um script cheio de if/else que ninguém consegue auditar.

LangGraphCrewAIAutoGenDeepAgents

O loop: perceber, decidir, agir, observar

Todo agente, do mais simples ao mais complexo, executa o mesmo loop quatro vezes — até esgotar um orçamento de passos ou chegar a uma resposta final:

1. perceber: o agente olha o estado atual (system prompt, histórico, resultado da última ação) e o que o usuário pediu.

2. decidir: o LLM produz ou uma resposta curável ao usuário, ou uma chamada de ferramenta com argumentos estruturados.

3. agir: o runtime valida os argumentos contra o schema da ferramenta, executa e captura o resultado.

4. observar: o resultado volta para o contexto e o loop reinicia.

A parte da literatura só tem valor se a parte do loop termina — e por isso todo framework expõe um limite máximo de passos e um critério de fim explícito.

loop.tsxtypescript

type Step = { kind: 'final'; answer: string }
       | { kind: 'tool';    tool: string; args: unknown };

async function agentLoop(state, llm, tools, maxSteps = 8) {
  for (let i = 0; i < maxSteps; i++) {
    const step: Step = await llm.decide(state);   // perceber + decidir
    if (step.kind === 'final') return step.answer; // fim
    const out = await tools[step.tool].run(step.args); // agir
    state = state.observe(step, out);              // observar
  }
  throw new Error('loop budget exhausted');
}

Por que usar um framework

O loop acima é curto, mas o que vem em volta não é: persistir estado entre passos, retomar a conversa depois de um erro, paralelizar ferramentas independentes, validar argumentos, gerenciar retries e expor observabilidade. Sem framework, você reimplementa isso em todo projeto — e reimplementa errado.

Um framework de agente entrega três coisas que vale pagar para ter: um grafo de execução explícito (você vê o que pode rodar quando), um estado tipado que sobrevive entre passos e a integração pronta com o modelo, o provedor de ferramentas e o storage de memória.

LangGraph: o agente como grafo de nós

LangGraph modela o agente como uma máquina de estados: cada nó é uma função (uma chamada ao LLM, uma execução de ferramenta, um filtro), cada aresta é uma decisão. O estado é um canal tipado que todos os nós leem e escrevem. Quando o grafo é cíclico, o agente pode iterar; quando é acíclico, ele é um pipeline.

O exemplo abaixo define um agente de pesquisa com dois nós (chamar modelo e executar ferramenta) e uma aresta condicional: se o modelo pediu ferramenta, vá para tools e volte; se devolveu resposta final, termine.

research-agent.tsxtypescript

import { StateGraph, END } from '@langchain/langgraph';
import { ChatAnthropic } from '@langchain/anthropic';

type S = { messages: Array<{ role: string; content: string }> };

const llm = new ChatAnthropic({ model: 'claude-opus-4' });
const tools = { search: { run: async (q: string) => `result for ${q}` } };

const graph = new StateGraph<S>({ channels: { messages: { value: [] } } })
  .addNode('llm', async (s) => ({ messages: s.messages.concat([await llm.invoke(s.messages)]) }))
  .addNode('tool', async (s) => ({ messages: s.messages.concat([{ role: 'tool', content: 'ok' }]) }))
  .addEdge('__start__', 'llm')
  .addConditionalEdges('llm',
    (s) => s.messages.at(-1)?.content.startsWith('CALL ') ? 'tool' : END,
    { tool: 'tool', [END]: END })
  .addEdge('tool', 'llm')
  .compile();

const out = await graph.invoke({ messages: [{ role: 'user', content: 'qual a capital da França?' }] });

DeepAgents (2025-2026): grafo de subagentes

, lançados em 2025, generalizam o modelo de grafo para múltiplos agentes cooperando: cada subagente é um nó com seu próprio prompt, ferramentas e orçamento, e o grafo descreve quem delega para quem. O orquestrador decompõe a tarefa, atribui subtarefas a subagentes e consolida o resultado.

A diferença prática para um framework clássico é que a unidade de composição deixou de ser uma ferramenta e passou a ser um agente inteiro. Quando a tarefa é 'pesquisar, analisar e redigir', você instancia três subagentes e os conecta por grafo, em vez de tentar um agente único com 40 ferramentas e um prompt monstro.

deepagents.pypython

from deepagents import Agent, Graph, tool as tasks


@tasks
def fetch_url(url: str) -> str:
    """Busca o conteúdo bruto de uma URL."""
    return requests.get(url, timeout=10).text

researcher = Agent(name='researcher', system='pesquise fontes primárias', tools=[fetch_url])
analyst    = Agent(name='analyst',    system='sintetize achados em tópicos')
writer     = Agent(name='writer',     system='produza o relatório final')

graph = Graph()
graph.add_edge('__start__', researcher)
graph.add_edge(researcher,   analyst)
graph.add_edge(analyst,      writer)
graph.add_edge(writer,       '__end__')

report = graph.run('relatório sobre o mercado de LLMs em 2026')

CrewAI e AutoGen: estilos vizinhos

CrewAI foca em times com papéis fixos (pesquisador, redator, revisor) e um processo de delega mais opinativo; é rápido para protótipos onde a divisão de trabalho é conhecida. AutoGen, da Microsoft, generaliza para múltiplos agentes conversando entre si, útil para exploração mas com tendência a loops longos e custo difícil de controlar.

A escolha entre frameworks raramente é técnica: é sobre o nível de estrutura que você quer no grafo. Quanto mais fixo o papel de cada nó, mais fácil de auditar; quanto mais flexível, mais poderoso para tarefas mal definidas e mais caro de operar.

Pontos fortes

loop explícito: cada framework pode ter certeza de quanto já rodou e o que falta rodar, simplificando budget e auditoria
estado tipado: o canal de estado passa a ser contrato, não dicionário solto — a IDE mostra erros antes de rodar
grafo visual: o fluxo do agente vira diagrama, e debugar vira olhar 'antes', executar nó, ler saída

Limitações

abstração vira lock-in: migrar entre frameworks custa reescrever o grafo, não só trocar a chamada
orçamento de loop é heurístico — sem guarda boa, agentes travam em ciclos ou estouram custo
LangGraph e DeepAgents ainda são projetos jovens (2024-2026); APIs e contratos mudam entre versões

DeepAgentsBiblioteca de agentes em grafo da LangChain que combina planning tool, filesystem tool e subagentes para resolver tarefas longas demais para um loop único. É referência prática de agente que não trava no terceiro tool call e o lugar onde você aprende a calibrar autonomia antes de soltar um agente real em produção.ver no glossário →

conexões no mapa

LLM - large language modelé o núcleoAgent frameworks
Agent frameworkshabilitaTool calling
Agent frameworkscoordena comOrchestration

atualizado em 14/10/2026 · fontes para aprofundar · reportar erro

em outros domínios

IAM - identidade e acessocloudsecprivilégio mínimo vale para o agente também

Estude antes

Desbloqueia

Orchestration

teste o que entendeu

Carregando perguntas…