Wat zijn LangGraph Deep Agents? De Harness uitgelegd

Een enkele tool-calling-loop is prima voor een taak die in vier stappen is afgerond. Het valt uit elkaar bij werk dat een uur duurt. Het model raakt de draad kwijt van wat het aan het doen was, de gespreksgeschiedenis groeit voorbij het contextvenster en één groot tool-resultaat vervuilt alles stroomafwaarts.

Wat een demo onderscheidt van een werkende agent is de harness: planning zodat de agent zijn eigen werk kan opsplitsen en bijhouden, een plek om tussenliggende status op te slaan die niet de berichtengeschiedenis is, delegatie zodat subtaken een schone context krijgen, en compactie zodat lange runs niet vastlopen. LangGraph Deep Agents is het verpakte antwoord van LangChain op al deze vier punten.

Wat zijn Deep Agents?

Deep Agents is een open-source, MIT-gelicentieerde agent harness van het LangChain-team, gedistribueerd als het deepagents-package in Python en deepagents op npm voor JavaScript en TypeScript. Het heeft sinds de release ongeveer 15.000 GitHub-sterren verzameld.

Het instappunt is een enkele functie:‍


Die aanroep geeft een gecompileerde LangGraph-graph terug, klaar om aan te roepen of te deployen. Daarachter heeft de harness al een planningstool, bestandssysteemtoegang, subagent-functionaliteit, samenvatting en een ingebouwde systeem-prompt gekoppeld die het model vertelt hoe het dit allemaal moet gebruiken. U levert het model en uw domeintools; de harness levert het steigerwerk.

Het JavaScript-package publiceert omgevingsspecifieke instappunten (deepagents voor Node, deepagents/browser voor browserveilig gebruik) en verklaart de LangChain runtime-packages als peer-dependencies, zodat uw applicatie de versies beheert en alles naar één gedeelde kopie herleidt.

Wat voegt de Harness daadwerkelijk toe?

Deep Agents is samengesteld uit middleware. Elk onderdeel koppelt tools en prompt-instructies aan de agent, en u kunt elk onderdeel overschrijven of verwijderen. Het begrijpen van de standaardset is de snelste manier om te begrijpen wat u krijgt.

Todo List Middleware

Voegt een write_todos planningstool toe. De agent splitst een doelstelling op in taken, legt deze vast en werkt de voortgang bij terwijl hij bezig is. Dit klinkt triviaal, maar is dat niet: een expliciet, beschrijfbaar plan is wat een model in staat stelt zijn plek te herstellen na twintig tool-aanroepen in plaats van af te dwalen.

File system Middleware

Voegt ls, read_file, write_file, edit_file, glob, grep en delete toe, plus een optionele execute tool wanneer de backend dit ondersteunt. Het bestandssysteem is het werkgeheugen van de agent. In plaats van een scrape van 40.000 tokens in de berichtengeschiedenis mee te dragen, schrijft de agent deze naar een bestand en grept later het gedeelte dat hij nodig heeft.

SubAgent Middleware

Voegt een task tool toe voor het delegeren van werk aan subagents, die elk draaien met een geïsoleerd contextvenster. De overkoepelende agent krijgt een resultaat terug in plaats van de gehele verkenning die het heeft geproduceerd, wat de meest effectieve vorm van contextbeheer is die beschikbaar is.

Er is ook asynchrone subagent-ondersteuning via het Agent Protocol, waarbij subagents direct terugkeren met een taak-ID en de hoofdagent blijft werken terwijl ze uitvoeren. Die taak-ID's worden opgeslagen in de agent-status onder async_tasks, zodat ze contextcompactie en offloading overleven. Het werkt met LangGraph Platform of elke self-hosted server die de Agent Protocol-specificatie implementeert.

Summarization Middleware

Comprimeert de berichtengeschiedenis wanneer een gesprek de contextlimiet overschrijdt. Dit is het onderdeel dat de meeste teams handmatig slecht schrijven, meestal door vanaf de voorkant af te snijden en stilzwijgend de oorspronkelijke instructies te verliezen.

Anthropic Prompt Caching Middleware

Vermindert automatisch redundante tokenverwerking bij Anthropic-modellen. Bij een lange agent-run waarbij de systeem-prompt en tool-definities bij elke stap opnieuw worden verzonden, is dit een directe kostenpost op de rekening.

Patch Tool Calls Middleware

Herstelt de berichtengeschiedenis wanneer tool-aanroepen worden onderbroken of geannuleerd voordat ze resultaten teruggeven. Een onopvallende oplossing voor een foutmodus die anders halverwege een run provider-side validatiefouten veroorzaakt.

Er worden er nog twee gekoppeld wanneer u de relevante functies gebruikt: MemoryMiddleware behoudt context over sessies heen, waarbij agentgeheugen uit AGENTS.md bestanden wordt geladen, en SkillsMiddleware maakt aangepaste vaardigheden mogelijk.

Het virtuele bestandssysteem en de backends

Het bestandssysteem verdient een eigen sectie omdat er zoveel van afhangt. Vaardigheden, geheugen, code-uitvoering en contextbeheer lezen en schrijven allemaal via hetzelfde virtuele bestandssysteem, en dat geldt ook voor uw eigen aangepaste tools en middleware.

Het is pluggbaar. Backends omvatten in-memory status, lokale schijf, de LangGraph store, composiet-routing over meerdere backends en sandbox-backends voor geïsoleerde uitvoering. Het wisselen van backends verandert waar bestanden fysiek leven zonder de agent-code te wijzigen, wat ervoor zorgt dat dezelfde agent kan draaien in een notebook, in CI en in productie.

De harness ondersteunt ook declaratieve permissieregels die bepalen welke bestanden en mappen de agent kan lezen of schrijven. Regels worden doorgegeven als een lijst bij het aanmaken van de agent, geëvalueerd in volgorde van declaratie waarbij de eerste match wint, en ze zijn van toepassing op de ingebouwde bestandssysteemtools. Waardevol om te weten voor iedereen die agents volgens het least-privilege principe ontwerpt: declaratieve subagents erven de bestandssysteembeperkingen van de ouder niet over. U moet een subagent zijn eigen FilesystemMiddleware-instantie geven om hem onafhankelijk te beperken.

Deep Agents is gebouwd op LangGraph, geen alternatief ervoor

Dit is waar de meeste artikelen over dit onderwerp de mist in gaan, dus het is goed om het duidelijk te stellen. Zoeken naar "deep agents vs langgraph" suggereert een keuze tussen twee opties. Die is er niet. create_deep_agent() geeft een LangGraph-graph terug. Deep Agents is LangGraph met een vooraf geassembleerde harness er bovenop.

LangChain beschrijft drie lagen van dezelfde stack:

• Deep Agents wanneer u de volledige harness wilt met planning, contextbeheer en delegatie al ingebouwd
• create_agent wanneer u een lichtere harness wilt zonder de gebundelde middleware
• LangGraph wanneer de agent-loop zelf niet de juiste vorm heeft en u een aangepaste graph nodig hebt

De lagen vullen elkaar aan in plaats van te concurreren. Elke LangGraph CompiledStateGraph kan worden doorgegeven als subagent aan een deep agent, waardoor aangepaste orchestratie naadloos aansluit bij de standaardinstellingen van de harness. U kunt beginnen met create_deep_agent(), tegen een workflow aanlopen die de standaard loop slecht afhandelt, dat ene onderdeel bouwen als een LangGraph-graph en het aan de harness overhandigen als een subagent. Er wordt niets weggegooid.

Als u nog aan het uitzoeken bent waar LangGraph zelf staat ten opzichte van het bredere LangChain-ecosysteem, behandelt onze LangChain vs LangGraph overzicht die laag.

Deep Agents vs create_agent vs LangGraph

De beslissing gaat minder over functionaliteit dan over hoeveel van de harness u zelf wilt beheren. Elke standaardinstelling die u accepteert is iets dat u niet hoeft te bouwen, en iets dat u niet kunt wijzigen zonder een laag lager te gaan.

Wanneer u welke laag gebruikt

Gebruik Deep Agents wanneer het werk een lange horizon heeft en een open einde: onderzoek dat tientallen bronnen beslaat, code-aanpassingen in meerdere bestanden, documentgeneratie waarbij de agent een plek nodig heeft om concepten te bewaren. Gebruik het ook wanneer u deze week een geloofwaardige agent wilt laten draaien in plaats van volgende maand.

Gebruik create_agent wanneer u precies weet welke tools u nodig hebt en de taak in een paar stappen is voltooid. Het laden van een planningstool en een virtueel bestandssysteem op een classificatie-agent van drie stappen voegt zonder reden prompt-overhead en latentie toe.

Gebruik LangGraph direct wanneer de control flow het werkelijke probleem is: expliciete vertakkingen, deterministische routing, menselijke goedkeuringsstappen bij specifieke nodes, cycli die geen tool-calling-loop zijn. Als u merkt dat u tegen de harness vecht om uw flow uit te drukken, bent u deze ontgroeid. Voor de multi-agent patronen die boven een enkele agent liggen, behandelt onze gids voor multi-agent orchestratie dit gebied.

Een beter alternatief voor productie: TrueForge Agent Harness

LangChain Deep Agents lost veel van het harde werk binnen een individuele agent op, waaronder planning, subagents, bestandssysteemtools, vaardigheden, geheugen en langdurige uitvoering. Maar zodra u agents over meerdere teams heen laat draaien, verschuift het probleem van het bouwen van de agent naar het beheren van de vloot.

TrueForge is TrueFoundry's open-source, leverancier-neutrale agent harness voor die runtime-laag. Het voert de agent-loop uit rond het model, inclusief planning, tool-aanroepen, contextbeheer, goedkeuringen en sessiestatus, terwijl u uw eigen modellen, MCP-servers en sandbox-providers kunt meebrengen.

U kunt het lokaal uitvoeren met npx @truefoundry/trueforge, of dezelfde harness deployen voor een team met Docker Compose of Helm. Bekijk de TrueForge-documentatie.

Het optimaliseren van de Agent Runtime

TrueForge biedt ook verschillende mechanismen om de hoeveelheid context en tool-data die het model bereikt te controleren.

Deferred tool loading betekent dat MCP-tool-schema's op aanvraag worden geladen in plaats van vooraf het venster te vullen. Code Mode stelt de agent in staat om meerdere tool-aanroepen binnen één sandbox-script te ketenen, zodat alleen de afgedrukte samenvatting in de context komt in plaats van elk tussenresultaat. Te grote tool-responses worden ge-offloaded naar een sandbox-bestand en vervangen door een pad en een voorbeeld. Compactie wordt geactiveerd bij 80% van de contextlengte van het model en ruilt oude geschiedenis in voor een gestructureerde samenvatting, wat het directe antwoord is op replay. Subagents draaien met hun eigen schone context en geven alleen het resultaat terug.

Het sandbox-model is de andere hefboom. De meeste harnesses verpakken de gehele sessie in een container. TrueForge behandelde de sandbox als een tool en start er pas één op wanneer de agent daadwerkelijk code moet uitvoeren, zodat één server veel agents tegelijk laat draaien en beurten die nooit code aanraken goedkoop blijven.

Meer dan een Python-bibliotheek

TrueForge is ook gestructureerd als een runtime in plaats van alleen een bibliotheekinterface.

De core server voert de agent-loop uit en biedt streaming, goedkeuringsstappen, subagent-delegatie, compactie en permanente sessies. Een HTTP API en TypeScript SDK (@truefoundry/trueforge-sdk) stellen dezelfde mogelijkheden programmatisch beschikbaar. Een afzonderlijke chat UI en UI SDK (@truefoundry/trueforge-ui) kunnen rechtstreeks worden gebruikt, aangepast in stijl, of worden ingebed in een ander product.

Dit geeft teams een deployment-oppervlak dat verder gaat dan de Python-agentdefinitie zelf: dezelfde runtime kan een applicatie, API of ingebedde agent-ervaring aansturen.

Modellen, MCP-servers en sandbox-providers zijn allemaal flexibel te kiezen. Wanneer er een goedkoper model uitkomt, verwijst u daarnaar in plaats van de agent opnieuw te schrijven, wat verklaart hoe dezelfde benchmark op GLM-5.2 dezelfde ~11 van de 14 taken oploste voor $ 2,90 per run.

Deep Agents vs TrueForge Benchmark

Het verschil tussen een agent framework en een agent runtime wordt duidelijker wanneer u ze vergelijkt op dezelfde workloads. TrueFoundry heeft TrueForge en Deep Agents gebenchmarkt op DevRev's Enterprise-Bench, die bestaat uit 14 cross-systeem enterprise-taken. Elke taak vereist dat de agent plant, MCP-tools aanroept over een CRM, project-tracker en document-store, de resultaten combineert en een antwoord teruggeeft dat voldoet aan de evaluatierubriek. Beide harnesses voerden dezelfde taken uit met dezelfde MCP-servers, en antwoorden werden beoordeeld door een blinde LLM-beoordelaar.

Met Opus 4.8 als constante factor produceerden de twee harnesses een vergelijkbare taaknauwkeurigheid, maar hun uitvoeringskosten verschilden:

De benchmark toont een relatief klein verschil in taaknauwkeurigheid, maar een veel groter verschil in uitvoeringskosten. TrueForge gebruikte minder dan een kwart van de tokens die door Deep Agents werden gebruikt en was ongeveer 2,5x goedkoper per run op hetzelfde model.

De Runtime-laag voor Productionele AI Agents

Draai productie-agents met een open-source runtime voor uw modellen, MCP-tools, sandboxing, goedkeuringen en observabiliteit.

Ontdek TrueForge

Bekijk op GitHub

Het verschil komt grotendeels voort uit de manier waarop de twee runtimes omgaan met orchestratie en context. Deep Agents biedt mogelijkheden zoals planning, een virtueel bestandssysteem en subagents, maar deze kunnen ook meer orchestratie en context toevoegen aan elke beurt. TrueForge kiest voor een slankere aanpak door gerichte tool-aanroepen en contextcompactie te gebruiken om te voorkomen dat grote geschiedenissen en tool-responses herhaaldelijk naar het model worden teruggestuurd. Dit is belangrijk omdat de kosten van een agent niet alleen worden bepaald door de modelprijs. Twee agent-systemen die hetzelfde model gebruiken, kunnen een heel verschillend tokenverbruik hebben, afhankelijk van hoe ze planning, tool-gebruik, contextbeheer en subagents implementeren.

De Agent Runtime verbinden met de Platformlaag

TrueForge kan ook worden verbonden met TrueFoundry's AI Gateway en MCP Gateway om de functies te bieden die belangrijk worden zodra agents geen geïsoleerde projecten meer zijn, waaronder gecentraliseerde modeltoegang, MCP-referenties, RBAC, budgetten, guardrails, rotatie van referenties en geünificeerde traces. Hiermee worden deze zaken verplaatst van individuele agentdefinities naar een gedeelde platformlaag.

Voor teams die Deep Agents evalueren voor productie is de benchmark een nuttige herinnering dat het framework slechts één onderdeel van de stack is. De runtime-architectuur rondom de agent kan een aanzienlijke impact hebben op tokenverbruik, latentie en kosten. TrueForge is ontworpen om die runtime-laag te bieden terwijl de keuzes voor het model en de infrastructuur open blijven.

Conclusie

Deep Agents, create_agent en LangGraph bevinden zich op verschillende abstractieniveaus in de LangChain agent-stack. create_agent geeft u een lichtgewicht agent-loop, terwijl LangGraph de onderliggende graph-primitieven biedt voor ontwikkelaars die de uitvoeringsstroom zelf moeten definiëren. Deep Agents bouwt voort op LangGraph om een completere agent harness te bieden met planning, subagents, contextbeheer en bestandssysteemfuncties.

De keuze komt daarom neer op hoeveel van de agent runtime u wilt beheren. Als een standaard agent-loop en ingebouwde functionaliteiten voldoende zijn, vermindert Deep Agents de hoeveelheid infrastructuur die u hoeft te bouwen. Als u een lichtgewicht loop nodig hebt, biedt create_agent een eenvoudiger startpunt. Wanneer de uitvoeringsstroom zelf de kernvereiste is, geeft LangGraph u de primitieven om deze expliciet te ontwerpen.

Voor teams die verder kijken dan het LangChain-ecosysteem kiest TrueForge voor een andere aanpak: een open-source, model-neutrale agent harness die de runtime-laag biedt terwijl u de controle houdt over het model en de onderliggende infrastructuur.

Veelgestelde vragen

V: Wat zijn LangGraph Deep Agents?

‍A: Deep Agents is LangChain's open-source, MIT-gelicentieerde agent harness gebouwd op LangGraph. Het aanroepen van create_deep_agent() geeft een gecompileerde LangGraph-graph terug waarbij planning, een virtueel bestandssysteem, subagent-delegatie, samenvatting en prompt caching al als middleware zijn gekoppeld. Het bestaat zodat teams de ondersteunende structuur die langlopende agents nodig hebben niet handmatig hoeven te bouwen.

V: Is Deep Agents een vervanging voor LangGraph?

‍A: Nee. Deep Agents is gebouwd op LangGraph en geeft een LangGraph-graph terug. Het zijn lagen van dezelfde stack, geen concurrerende opties. Gebruik Deep Agents wanneer de standaard agentvorm past bij uw taak, en schakel over naar LangGraph wanneer u een aangepaste control flow nodig hebt. Elke LangGraph-graph kan weer als subagent worden doorgegeven aan een deep agent.

V: Welke middleware bevat een deep agent standaard?

‍A: Zes onderdelen: TodoListMiddleware voor planning, FilesystemMiddleware voor bestandsoperaties, SubAgentMiddleware voor delegatie met geïsoleerde context, SummarizationMiddleware voor contextcompactie, AnthropicPromptCachingMiddleware voor tokenbesparing op Anthropic-modellen, en PatchToolCallsMiddleware voor het herstellen van onderbroken tool-aanroepen. MemoryMiddleware en SkillsMiddleware worden gekoppeld wanneer u geheugen of vaardigheden gebruikt.

V: Ondersteunt TrueFoundry MCP en AI agents?

‍A: Ja. TrueFoundry bevat een MCP Gateway, Agent Gateway en een MCP & Agents Registry met toegangsbeheer op tool-niveau. Agents gebouwd op Deep Agents, LangGraph, CrewAI, AutoGen of aangepaste frameworks kunnen allemaal gecentraliseerd worden gedeployd en beheerd.

V: Kan ik TrueFoundry in mijn eigen VPC of on-prem deployen?

‍A: Ja. TrueFoundry draait in uw VPC, on-prem, air-gapped, hybride of over meerdere clouds, en er verlaat geen data uw domein. Dit is de belangrijkste reden waarom gereguleerde ondernemingen hiervoor kiezen in plaats van SaaS-only gateways.

V: Integreert het met mijn bestaande observabiliteits-stack?

‍A: Ja. De gateway voldoet aan OpenTelemetry en kan worden gekoppeld aan Grafana, Datadog, Prometheus of wat u al gebruikt, waarbij elke request wordt getraced van prompt tot tool- en model-uitvoering.

Gerelateerde artikelen

• CrewAI vs LangGraph — hoe LangGraph zich verhoudt tot het andere grote multi-agent framework
• AutoGen vs LangGraph — dezelfde vergelijking met het framework van Microsoft
• LangGraph Pricing — wat LangGraph en LangGraph Platform daadwerkelijk kosten
• LLM Agents: architectuur en patronen — de basis achter deze post
• TrueForge: een open-source agent harness — onze visie op hetzelfde probleem