Deep Agents vs LangGraph: De qual camada você realmente precisa?

Criar um agente envolve muito mais do que conectar um LLM a algumas ferramentas. Você também precisa decidir como o agente gerencia o estado, lida com o contexto, chama ferramentas, executa tarefas e determina o próximo passo.

LangGraph e Deep Agents resolvem esses problemas em diferentes níveis de abstração. O LangGraph oferece aos desenvolvedores as primitivas para definir e controlar o fluxo de execução de um agente, enquanto o Deep Agents fornece uma estrutura de agente pré-construída de alto nível sobre o LangGraph.

Ambos resolvem o mesmo problema fundamental. Um modelo raciocina, mas não consegue agir. Ele não abrirá um arquivo, chamará uma API, executará o código que acabou de escrever ou se lembrará do que decidiu quatro turnos atrás. Algo precisa envolver o modelo para preencher essa lacuna e continuar preenchendo-a durante todo o tempo que a tarefa exigir. O LangGraph lhe dá as peças para construir isso. O Deep Agents entrega o sistema pronto para você.

O que é o LangGraph?

LangGraph é um runtime para agentes. Você modela o fluxo de trabalho como um grafo direcionado: os nós são operações discretas, as arestas definem o que será executado a seguir e um esquema de estado tipado percorre cada etapa. A execução percorre sua estrutura até que um nó retorne END.

Uma construção no LangGraph geralmente segue este padrão:

• Defina o esquema de estado. Um objeto tipado do qual cada nó lê e no qual escreve.
• Escreva os nós. Cada um é uma função: chamar um modelo, acessar uma ferramenta, transformar o estado, validar algo.
• Conecte as arestas. Sequências fixas, além de arestas condicionais que se ramificam com base no que o estado contém naquele momento.
• Adicione pontos de verificação (checkpointers). Persistência que permite que uma execução interrompida seja retomada a partir da última etapa concluída, em vez de começar do zero.
• Adicione interrupções. Pontos de pausa onde um humano revisa ou aprova antes que a execução continue.

Os pontos de verificação e as interrupções são os verdadeiros diferenciais aqui, e é por isso que o LangGraph acabou se tornando a base de quase tudo no ecossistema LangChain. Tanto o LangChain quanto o create_agent e os Deep Agents são executados nele.

O LangGraph funciona melhor quando:

• O fluxo de trabalho tem uma estrutura definida, e essa estrutura codifica um conhecimento de domínio que você não quer que um modelo coloque em dúvida
• Passos determinísticos e passos de modelo se misturam no mesmo pipeline
• Um humano precisa aprovar em um ponto específico, e não "em algum momento do loop"
• As execuções são longas o suficiente para que retomar a partir de um ponto de verificação seja importante
• Você precisa de ramificações ou loops de retorno para estágios anteriores que nenhum loop fixo permitiria

O próprio exemplo do LangChain é um pipeline de candidatura a aluguel: extrair renda e histórico de crédito de documentos, pontuar com base nos critérios do proprietário e, então, aprovar automaticamente, rejeitar ou escalar casos limítrofes. Apenas o primeiro passo utiliza um LLM. O restante é código fixo, e deve permanecer como código fixo.

O que são Deep Agents?

Deep Agents é um ambiente de execução para agentes. Possui o mesmo loop central do create_agentdo LangChain, mas com uma abordagem opinativa e práticas de engenharia de contexto integradas por padrão. O LangChain o descreve como o agente principal mais um conjunto de middleware e, por baixo, ele ainda é um grafo do LangGraph.

O que vem incluído:

• Um sistema de arquivos, para que o agente leia e escreva contextos que não deveriam estar ocupando a janela de contexto
• Subagentes, que realizam tarefas especializadas sem sobrecarregar a thread principal
• Habilidades, instruções e scripts que o agente carrega sob demanda
• Memória, para que o agente retenha aprendizados entre diferentes execuções
• Estrutura de planejamento, o mecanismo que decompõe uma tarefa antes de executá-la

Você obtém um agente a partir de create_deep_agent com um modelo, um conjunto de ferramentas e um prompt de sistema. Sem necessidade de criar grafos.

A distinção em relação ao LangGraph está em quem escreve o loop. Com o LangGraph, você declara os nós e as condições, e o fluxo de controle é seu. Com os Deep Agents, você fornece ferramentas e instruções e inicia o processo, e o modelo decide o que acontece a seguir dentro de um loop escrito por outra pessoa. Se você quiser uma explicação mais detalhada sobre essa diferença, nós a escrevemos separadamente em agent harness vs agent framework.

O Deep Agents funciona melhor quando:

• O caminho do agente depende do que foi encontrado na etapa anterior, portanto, não há um grafo para desenhar
• Você quer um agente capaz em horas, em vez de dias
• Pesquisa, investigação em várias etapas ou qualquer coisa que se ramifique por várias fontes
• Você já investiu no LangGraph e quer o loop sem precisar construí-lo manualmente
• Sua equipe prefere herdar decisões de gerenciamento de contexto em vez de tomá-las

Deep Agents vs LangGraph: Principais Diferenças

Ambos visam o mesmo resultado e ocupam níveis diferentes na mesma pilha, e é por isso que a pergunta "qual é o melhor" não tem uma resposta definitiva. Um exige que você projete o comportamento do agente. O outro decide a maior parte por você e cobra em tokens pelas partes que decidiu de forma generosa.

Uma alternativa melhor para produção: TrueForge Agent Harness

O LangChain Deep Agents resolve grande parte do trabalho pesado dentro de um agente individual, incluindo planejamento, subagentes, ferramentas de sistema de arquivos, habilidades, memória e execução de longa duração. Mas, quando você começa a executar agentes em várias equipes, o problema deixa de ser a construção do agente e passa a seroperar a frota.

TrueForgeé o harness de agentes de código aberto e independente de fornecedor da TrueFoundry para essa camada de tempo de execução. Ele executa o loop do agente em torno do modelo, incluindo planejamento, chamadas de ferramentas, gerenciamento de contexto, aprovações e estado da sessão, permitindo que você utilize seus próprios modelos, servidores MCP e provedores de sandbox.

Você pode executá-lo localmente comnpx @truefoundry/trueforge, ou implante o mesmo harness para uma equipe usando Docker Compose ou Helm.Consulte a documentação do TrueForge.

Otimizando o tempo de execução do agente

O TrueForge também oferece vários mecanismos para controlar a quantidade de contexto e dados de ferramentas que chegam ao modelo.

Carregamento de ferramentas sob demandasignifica que os esquemas de ferramentas MCP são carregados conforme a necessidade, em vez de preencherem a janela de contexto antecipadamente. O Modo de Código permite que o agente encadeie várias chamadas de ferramentas dentro de um único script de sandbox, de modo que apenas o resumo impresso entre no contexto, e não cada resultado intermediário.Respostas de ferramentas muito grandes são transferidaspara um arquivo de sandbox e substituídas por um caminho e uma prévia. A compactação é acionada em 80% do limite de contexto do modelo e substitui o histórico antigo por um resumo estruturado, que é a resposta direta para a repetição. Subagentes são executados com seu próprio contexto limpo e retornam apenas o resultado.

O modelo de sandbox é a outra alavanca. A maioria das estruturas envolve toda a sessão em um contêiner. O TrueForge trata o sandbox como uma ferramenta e o inicializa apenas quando o agente realmente precisa executar código; assim, um servidor executa vários agentes simultaneamente e as tarefas que não envolvem código permanecem de baixo custo.

Muito mais que uma biblioteca Python

O TrueForge também é estruturado como um runtime, e não apenas como uma interface de biblioteca.

Oservidor principalexecuta o loop do agente e fornece streaming, portões de aprovação, delegação de subagentes, compactação e sessões persistentes. UmAPI HTTP e SDK TypeScript(@truefoundry/trueforge-sdk) expõe as mesmas capacidades programaticamente. Umainterface de chat e SDK de UI(@truefoundry/trueforge-ui) separada pode ser usada diretamente, personalizada ou incorporada a outro produto.

Isso oferece às equipes uma superfície de implantação que vai além da definição do agente em Python: o mesmo runtime pode alimentar uma aplicação, uma API ou uma experiência de agente incorporada.

Modelos, servidores MCP e provedores de sandbox são de sua escolha. Quando um modelo mais barato é lançado, você aponta para ele em vez de reescrever o agente, que é como o mesmo benchmark executado no GLM-5.2 resolveu cerca de 11 das 14 tarefas por US$ 2,90 por execução.

Deep Agents vs. Benchmark do TrueForge

A diferença entre um framework de agente e um runtime de agente fica mais clara quando você os compara com as mesmas cargas de trabalho. A TrueFoundry comparou oTrueForge e o Deep Agentsno Enterprise-Bench da DevRev, que consiste em 14 tarefas corporativas entre sistemas. Cada tarefa exige que o agente planeje, chame ferramentas MCP em um CRM, rastreador de projetos e repositório de documentos, combine os resultados e retorne uma resposta que atenda aos critérios de avaliação. Ambas as estruturas executaram as mesmas tarefas com os mesmos servidores MCP, e as respostas foram pontuadas por um juiz LLM cego.

ComOpus 4.8 mantido constante, os dois ambientes de execução produziram uma precisão de tarefa semelhante, mas seus custos de execução foram diferentes:

O benchmark mostra uma diferença relativamente pequena na precisão da tarefa, mas uma diferença muito maior no custo de execução. O TrueForge usoumenos de um quarto dos tokensusados pelo Deep Agents e foi aproximadamente2,5 vezes mais barato por execuçãono mesmo modelo.

The Runtime Layer for Production AI Agents

Run production agents with an open-source runtime for your models, MCP tools, sandboxing, approvals, and observability.

Explore TrueForge

View on GitHub

A diferença vem, em grande parte, de como os dois runtimes lidam com a orquestração e o contexto. O Deep Agents oferece recursos como planejamento, um sistema de arquivos virtual e subagentes, mas eles também podem adicionar mais orquestração e contexto a cada turno. O TrueForge adota uma abordagem mais enxuta, usando chamadas de ferramentas direcionadas e compactação de contexto para evitar o envio repetido de grandes históricos e respostas de ferramentas de volta ao modelo. Isso é importante porqueo custo de um agente não é determinado apenas pelo preço do modelo. Dois sistemas de agentes executando o mesmo modelo podem ter um consumo de tokens muito diferente, dependendo de como implementam o planejamento, o uso de ferramentas, o gerenciamento de contexto e os subagentes.

Conectando o Runtime do Agente à Camada de Plataforma

O TrueForge também pode se conectar ao AI Gateway e ao MCP Gateway da TrueFoundry para fornecer os controles que se tornam importantes quando os agentes deixam de ser projetos isolados, incluindoacesso centralizado a modelos, credenciais MCP, RBAC, orçamentos, guardrails, rotação de credenciais e rastreamento unificado. Isso transfere essas preocupações das definições individuais de agentes para uma camada de plataforma compartilhada.

Para equipes que avaliam o Deep Agents para produção, o benchmark é um lembrete útil de que o framework é apenas uma parte da pilha. Aarquitetura de runtime em torno do agente pode ter um impacto significativo no uso de tokens, na latência e no custo. O TrueForge foi projetado para fornecer essa camada de runtime, mantendo as escolhas de modelo e infraestrutura abertas.

Então, qual você deve escolher?

Escolha LangGraph quando o formato do grafo for o que realmente importa. Portões de conformidade em nós específicos, loops condicionais para estágios anteriores, um pipeline onde apenas uma etapa deve interagir com um modelo. Se você já usa o LangGraph e o fluxo é genuinamente em formato de grafo, continue com ele.

Escolha um harness quando você se pegar criando manualmente um loop que já existe em algum lugar. Nesse caso, a questão é apenas qual "harness" (estrutura de suporte) usar, e isso é uma questão de gerenciamento de contexto; portanto, leia a documentação sobre compactação, descarregamento e carregamento diferido antes de se comprometer. Se nada mencionar esses recursos, você está diante de um framework que apenas se rotula como um "harness".

Escolha deepagents especificamente se você deseja o ecossistema e as abstrações do LangChain e se o perfil de consumo de tokens for aceitável para sua carga de trabalho. Execuções curtas não sentirão a diferença.

Escolha TrueForge se execuções longas forem o seu padrão, se você precisar de uma API HTTP ou interface de usuário integrada em vez de uma biblioteca, se quiser licenciamento MIT sem compromisso com ecossistemas, ou se o custo por execução precisar passar pelo crivo do departamento financeiro. Nossa alternativas ao LangGraph análise detalhada cobre as opções de nível de framework, caso esse seja o nível que você realmente precisa.

E, muitas vezes, a resposta é ambos. Um framework lida com a orquestração entre agentes ou com o fluxo de trabalho determinístico dentro do qual um agente baseado em "harness" opera. Um "harness" executa os próprios agentes. Os dois erros a evitar são: usar um framework para reconstruir um loop que você poderia ter herdado e forçar um "harness" a seguir uma sequência rígida de conformidade apenas descrevendo-a em um prompt e torcendo para que funcione.

Perguntas frequentes

P: Qual é a diferença entre deep agents e LangGraph?

R: O LangGraph é um runtime de agentes e o Deep Agents é um "harness" de agentes construído sobre ele. Com o LangGraph, você declara nós, arestas e estados, e escreve o fluxo de controle por conta própria. Com o Deep Agents, o loop já está pronto, juntamente com um sistema de arquivos, subagentes, habilidades e memória; portanto, você fornece apenas as ferramentas e as instruções. O Deep Agents compila para um grafo do LangGraph por baixo dos panos.

P: O Deep Agents substitui o LangGraph?

R: Não, e não pode, porque ele roda sobre o LangGraph. Um "harness" oferece um loop fixo que é conduzido por um modelo. Se o seu fluxo de trabalho precisa de uma topologia arbitrária, portões de validação em nós nomeados ou loops condicionais para estágios anteriores, nenhum "harness" conseguirá expressar isso, e o LangGraph continua sendo a ferramenta certa. Muitos sistemas em produção utilizam ambos em camadas diferentes.

P: Qual é mais barato de executar, deepagents ou outro "harness"?

R: Em nosso teste de benchmark corporativo (Enterprise-Bench), o deepagents no Opus 4.8 consumiu 16,5 milhões de tokens e custou US$ 21 por execução, contra 3,8 milhões de tokens e US$ 8,50 do TrueForge no mesmo modelo e nas mesmas 14 tarefas, com uma precisão equivalente em uma tarefa. A diferença vem da reprodução do contexto acumulado em vez de sua compactação, além da estrutura de suporte carregada a cada turno.

P: Posso executar qualquer um deles na minha própria VPC ou localmente (on-prem)?

R: Sim. Ambos são de código aberto e podem ser auto-hospedados. O TrueForge roda a partir de um único npx comando localmente, ou via Docker Compose e Helm para implantações de equipe com Postgres, Redis, réplicas e login OIDC. A plataforma gerenciada da TrueFoundry também pode ser executada de forma auto-hospedada, on-premise, em ambiente isolado (air-gapped) ou híbrido, para que nenhum dado saia do seu domínio.

P: Como faço para governar modelos e servidores MCP em muitos agentes?

R: Por meio de uma camada de gateway, assim que as chaves autogerenciadas deixarem de ser escaláveis. A TrueFoundry Gateway de IA coloca mais de 1.000 LLMs atrás de uma única API compatível com OpenAI, com aproximadamente 3 a 4 ms de latência adicional e mais de 350 RPS em uma única vCPU, com RBAC, orçamentos, guardrails e rotação de credenciais, além de rastreamento OpenTelemetry para Grafana, Datadog ou Prometheus. Agentes criados no LangGraph, deepagents ou qualquer outra ferramenta são governados da mesma forma.

Leituras relacionadas

• Harness de Agentes vs. Framework de Agentes: Qual é a diferença real?: a distinção de categoria por trás de toda essa decisão
• Alternativas ao LangChain Deep Agents: o campo de harness caso o deepagents não seja a opção ideal
• TrueForge vs. Claude Managed Agents: Até 75% mais baratometodologia e resultados completos do Enterprise-Bench
• Melhores Harnesses de Agentes Open Source: Comparativo dos 5 Principais Projetos: como as opções abertas se comparam
• Alternativas ao LangGraph: 5 Opções Comparadas para 2026: se a camada de framework é a que você precisa

Conclusão

A escolha entre Deep Agents e LangGraph depende de em qual camada o seu problema reside, e você pode resolver isso com uma pergunta: o caminho do agente tem um formato que você deseja criar, ou ele é descoberto conforme a execução acontece?

Se tem um formato, use LangGraph. Se não tem, você precisa de um harness, e então o diferencial é o que esse harness faz com sua janela de contexto na quadragésima interação. Vale a pena medir isso antes de construir sobre ele.

npx @truefoundry/trueforge coloca um agente em execução em cerca de um minuto, ou veja como o TrueForge lida com o contexto em execuções longas.