Deep Agents vs LangGraph: Welke laag heb je daadwerkelijk nodig?

Het bouwen van een agent omvat meer dan het verbinden van een LLM met een paar tools. Je moet ook beslissen hoe de agent de status beheert, context afhandelt, tools aanroept, taken uitvoert en bepaalt wat de volgende stap is.

LangGraph en Deep Agents lossen deze problemen op op verschillende abstractieniveaus. LangGraph geeft ontwikkelaars de primitieven om de uitvoeringsstroom van een agent te definiëren en te beheren, terwijl Deep Agents een vooraf gebouwde agent harness op een hoger niveau biedt, gebouwd op LangGraph.

Beide lossen hetzelfde onderliggende probleem op. Een model redeneert, maar kan niet handelen. Het zal geen bestand openen, geen API aanroepen, de code die het zojuist heeft geschreven niet uitvoeren en niet onthouden wat het vier stappen geleden heeft besloten. Iets moet rond het model zitten om dat gat te dichten, en het te blijven dichten zolang de taak duurt. LangGraph geeft je de onderdelen om dat te bouwen. Deep Agents levert het gemonteerd aan je op.

Wat is LangGraph?

LangGraph is een agent runtime. Je modeleert de workflow als een gerichte grafiek: knooppunten (nodes) zijn discrete operaties, randen (edges) definiëren wat vervolgens wordt uitgevoerd, en een getypeerd statusschema loopt door elke stap. De uitvoering doorloopt je structuur totdat een knooppunt END retourneert.

Een LangGraph-build ziet er meestal zo uit:

• Definieer het statusschema. Een getypeerd object waar elk knooppunt van leest en naar schrijft.
• Schrijf de knooppunten. Elk knooppunt is een functie: roep een model aan, gebruik een tool, transformeerde status, valideer iets.
• Verbind de randen. Vaste reeksen, plus voorwaardelijke randen die vertakken op basis van wat de status op dat moment bevat.
• Voeg checkpointers toe. Persistentie waarmee een gecrashte uitvoering kan worden hervat vanaf de laatst voltooide stap in plaats van vanaf het begin.
• Voeg onderbrekingen toe. Pauzepunten waar een mens controleert of goedkeurt voordat de uitvoering doorgaat.

De checkpointers en onderbrekingen zijn de echte onderscheidende factoren hier, en ze zijn de reden waarom LangGraph uiteindelijk onder bijna alles in de LangChain-stack terecht is gekomen. Zowel create_agent als Deep Agents van LangChain draaien erop.

LangGraph werkt het beste wanneer:

• De workflow een specifieke vorm heeft, en die vorm domeinkennis bevat waarover je het model niet wilt laten twijfelen
• Deterministische stappen en modelstappen worden gecombineerd in dezelfde pipeline
• Een mens op een specifiek punt moet goedkeuren, niet "ergens in de lus"
• Uitvoeringen lang genoeg duren dat hervatten vanaf een checkpoint van belang is
• Je vertakkingen of lussen terug naar eerdere fasen nodig hebt die een vaste lus niet zou toestaan

Het eigen voorbeeld van LangChain is een verwerkingspipeline voor huuraanvragen: extraheer inkomen en kredietgeschiedenis uit documenten, beoordeel dit aan de hand van de criteria van de verhuurder, en keur vervolgens automatisch goed, afwijs of escaleer twijfelgevallen. Alleen de eerste stap maakt gebruik van een LLM. De rest is vaste code, en dat moet zo blijven.

Wat zijn Deep Agents?

Deep Agents is een agent harness. Dezelfde kernlus als de create_agent van LangChain, maar opinieerend, met standaard ingebouwde context-engineeringpraktijken. LangChain beschrijft het als de kernagent plus een reeks middleware, en onder de motorkap is het nog steeds een LangGraph-grafiek.

Wat er standaard wordt meegeleverd:

• Een bestandssysteem, zodat de agent context leest en schrijft die hij niet in het contextvenster hoeft mee te dragen
• Subagents, die gespecialiseerd werk uitvoeren zonder de hoofdthread te belasten
• Vaardigheden (skills), instructies en scripts die de agent op verzoek laadt
• Geheugen, zodat de agent inzichten meeneemt over verschillende uitvoeringen heen
• Planningsstructuur, het mechanisme dat een taak ontleed voordat deze wordt uitgevoerd

Je krijgt een agent van create_deep_agent met een model, een set tools en een systeem-prompt. Geen grafiek om zelf te schrijven.

Het verschil met LangGraph draait om wie de lus schrijft. Met LangGraph declareer je de knooppunten en voorwaarden, en is de besturingsstroom van jou. Met Deep Agents lever je tools en instructies aan en druk je op start, waarna het model beslist wat er vervolgens gebeurt binnen een lus die door iemand anders is geschreven. Als je de langere versie van die redenering wilt lezen, hebben we die afzonderlijk beschreven in agent harness vs agent framework.

Deep Agents werkt het beste wanneer:

• Het pad van de agent afhangt van wat de vorige stap heeft opgeleverd, waardoor er geen vooraf vastgestelde grafiek te tekenen valt
• Je binnen enkele uren in plaats van dagen een krachtige agent wilt hebben
• Onderzoek, meerstapsverkenning of alles wat zich vertakt over meerdere bronnen centraal staat
• Je al hebt geïnvesteerd in LangGraph en de lus wilt gebruiken zonder deze handmatig te bouwen
• Je team liever keuzes op het gebied van contextbeheer overneemt dan ze zelf moet maken

Deep Agents vs LangGraph: Kernverschillen

Beide streven hetzelfde resultaat na, maar ze bevinden zich op verschillende hoogten in dezelfde stack, wat verklaart waarom "welke beter is" geen eenduidig antwoord heeft. De ene vraagt je om het gedrag van de agent te ontwerpen. De andere beslist het meeste voor je en brengt de delen die ruimhartig zijn ontworpen in tokens in rekening.

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 je agents over meerdere teams heen gebruikt, verschuift het probleem van het bouwen van de agent naar het beheren van de gehele vloot.

TrueForge is het open-source, leverancier-neutrale agent harness van TrueFoundry voor die runtimelaag. Het voert de agent-lus om het model heen uit, inclusief planning, tool-aanroepen, contextbeheer, goedkeuringen en sessiestatus, terwijl je je eigen modellen, MCP-servers en sandbox-providers kunt meebrengen.

Je kunt het lokaal uitvoeren met npx @truefoundry/trueforge, of hetzelfde harness implementeren voor een team met behulp van Docker Compose of Helm. Bekijk de TrueForge-documentatie.

De Agent Runtime optimaliseren

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

Uitgesteld laden van tools (deferred tool loading) betekent dat MCP-toolschema's op verzoek worden geladen in plaats van vooraf het venster te vullen. Code Mode stelt de agent in staat om meerdere tool-aanroepen te koppelen binnen één sandbox-script, zodat alleen de afgedrukte samenvatting in de context komt in plaats van elk tussenresultaat. Te grote tool-responses worden overgezet naar een sandbox-bestand en vervangen door een pad en een voorbeeld. Compactie wordt geactiveerd bij 80% van de contextlengte van het model en vervangt oude geschiedenis door een gestructureerde samenvatting, wat het directe antwoord is op herhalingslussen. Subagents draaien met hun eigen schone context en leveren alleen het resultaat terug.

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

Meer dan een Python-bibliotheek

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

De kernserver voert de agent-lus uit en biedt streaming, goedkeuringspoorten, 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 qua thema of worden ingebed in een ander product.

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

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

Deep Agents vs TrueForge Benchmark

Het verschil tussen een agent framework en een agent runtime wordt duidelijker wanneer je ze op dezelfde werkbelastingen vergelijkt. TrueFoundry heeft TrueForge en Deep Agents gebenchmarkt op DevRev's Enterprise-Bench, die bestaat uit 14 bedrijfsoverschrijdende taken. Elke taak vereist dat de agent plant, MCP-tools aanroept over een CRM, projecttracker en documentopslag, de resultaten combineert en een antwoord retourneert dat voldoet aan het evaluatieraster. Beide harnesses voerden dezelfde taken uit met dezelfde MCP-servers, en de antwoorden werden beoordeeld door een blinde LLM-beoordelaar.

Met Opus 4.8 als constante factor leverden de twee harnesses vergelijkbare taaknauwkeurigheid op, maar hun uitvoeringskosten verschilden aanzienlijk:

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 ruwweg 2,5x goedkoper per run op hetzelfde model.

De Runtimelaag voor Productie-AI-Agents

Draai productie-agents met een open-source runtime voor je modellen, MCP-tools, sandboxing, goedkeuringen en waarneembaarheid (observability).

Ontdek TrueForge

Bekijk op GitHub

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

De Agent Runtime verbinden met de Platformlaag

TrueForge kan ook worden verbonden met de AI Gateway en MCP Gateway van TrueFoundry om de beheersmechanismen te bieden die belangrijk worden zodra agents geen geïsoleerde projecten meer zijn, waaronder gecentraliseerde modeltoegang, MCP-inloggegevens, RBAC, budgetten, guardrails, rotatie van inloggegevens 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 rond de agent kan een aanzienlijke impact hebben op tokenverbruik, latency en kosten. TrueForge is ontworpen om die runtimelaag te bieden terwijl de keuzes voor het model en de infrastructuur open blijven.

Welke moet je nu kiezen?

Kies voor LangGraph wanneer de structuur van de grafiek de werkelijke waarde biedt. Nalevingspoorten bij specifieke knooppunten, voorwaardelijke lussen terug naar eerdere fasen, een pipeline waarin slechts één stap ooit een model mag raadplegen. Als je al LangGraph gebruikt en de stroom daadwerkelijk de vorm van een grafiek heeft, blijf daar dan bij.

Kies voor een harness wanneer je merkt dat je handmatig een lus aan het bouwen bent die ergens anders al bestaat. Dan is de enige vraag nog welk harness, en dat is een vraag over contextbeheer. Lees dus de documentatie over compactie, offloading en uitgesteld laden voordat je een keuze maakt. Als niets daarvan wordt genoemd, kijk je naar een framework dat het label van een harness draagt.

Kies specifiek voor deepagents als je het ecosysteem en de abstracties van LangChain wilt en het tokenprofiel acceptabel is voor je werkbelasting. Bij korte uitvoeringen zul je het verschil niet merken.

Kies voor TrueForge als lange uitvoeringen voor jou de standaard zijn, als je een HTTP API of ingebedde UI nodig hebt in plaats van een bibliotheek, als je een MIT-licentie wilt zonder verplichtingen aan een specifiek ecosysteem, of als de kosten per uitvoering bestand moeten zijn tegen vragen van de financiële afdeling. Onze analyse van LangGraph-alternatieven behandelt de opties op frameworkniveau als blijkt dat dat de laag is die je daadwerkelijk nodig hebt.

En vaak is het antwoord: beide. Een framework verzorgt de orchestratie tussen agents, of de deterministische workflow waarin een door een harness aangestuurde agent zich bevindt. Een harness voert de agents zelf uit. De twee valkuilen die je moet vermijden zijn het gebruiken van een framework om een lus te herbouwen die je had kunnen overnemen, en het dwingen van een harness door een strikte nalevingsreeks door deze in een prompt te beschrijven en te hopen dat het goed gaat.

FAQ

V: Wat is het verschil tussen deep agents en LangGraph?

A: LangGraph is een agent runtime en Deep Agents is een agent harness die daarop is gebouwd. Met LangGraph declareer je zelf knooppunten, randen en status, en schrijf je de besturingsstroom handmatig. Met Deep Agents is de lus al geschreven, samen met een bestandssysteem, subagents, vaardigheden en geheugen, zodat je in plaats daarvan tools en instructies aanlevert. Deep Agents wordt onder de motorkap gecompileerd naar een LangGraph-grafiek.

V: Is Deep Agents een vervanging voor LangGraph?

A: Nee, en dat kan het ook niet zijn, omdat het op LangGraph draait. Een harness geeft je een vaste lus die door een model wordt aangestuurd. Als je workflow een willekeurige topologie, validatiepoorten bij specifieke knooppunten of voorwaardelijke lussen terug naar eerdere fasen vereist, kan geen enkel harness dat uitdrukken en blijft LangGraph het juiste hulpmiddel. Veel productiesystemen draaien beide op verschillende lagen.

V: Welke is goedkoper in gebruik, deepagents of een ander harness?

A: Tijdens onze Enterprise-Bench-test gebruikte deepagents op Opus 4.8 16,5M tokens en $ 21 per run, vergeleken met 3,8M tokens en $ 8,50 voor TrueForge op hetzelfde model en voor dezelfde 14 taken, met een nauwkeurigheidsverschil van hooguit één taak. Het verschil ontstaat door het herhalen van opgebouwde context in plaats van deze te compacteren, plus de ondersteunende structuur (scaffolding) die bij elke stap wordt meegevoerd.

V: Kan ik een van beide in mijn eigen VPC of on-premise uitvoeren?

A: Ja. Beide zijn als open-source zelf te hosten. TrueForge draait lokaal vanuit één enkel npx-commando, of via Docker Compose en Helm voor teamimplementaties met Postgres, Redis, replica's en OIDC-login. Het beheerde platform van TrueFoundry draait eveneens self-hosted, on-prem, air-gapped of hybride, zodat er geen data je domein verlaat.

V: Hoe beheer ik modellen en MCP-servers over een groot aantal agents?

A: Via een gateway-laag, zodra zelfbeheerde sleutels niet langer schaalbaar zijn. TrueFoundry's AI Gateway plaatst 1.000+ LLM's achter één OpenAI-compatibele API met een toegevoegde latency van ongeveer 3 tot 4 ms en 350+ RPS op een enkele vCPU, inclusief RBAC, budgetten, guardrails en rotatie van inloggegevens, plus OpenTelemetry-traces naar Grafana, Datadog of Prometheus. Agents gebouwd op LangGraph, deepagents of iets anders worden op dezelfde manier beheerd.

Gerelateerde artikelen

• Agent Harness vs Agent Framework: Wat is daadwerkelijk het verschil?: het categorieverschil dat ten grondslag ligt aan deze hele beslissing
• LangChain Deep Agents-alternatieven: het aanbod aan harnesses als deepagents niet de juiste keuze is
• TrueForge vs Claude Managed Agents: Tot 75% goedkoper: volledige Enterprise-Bench-methodologie en resultaten
• Beste Open-Source Agent Harness: Top 5 projecten vergeleken: hoe de open opties zich tot elkaar verhouden
• LangGraph-alternatieven: 5 opties vergeleken voor 2026: als de frameworklaag is wat je nodig hebt

Conclusie

Deep Agents vs LangGraph komt neer op de vraag op welke laag je probleem zich bevindt, en dat kun je vaststellen met één vraag: heeft het pad van de agent een vaste vorm die je zelf wilt ontwerpen, of wordt het pas ontdekt naarmate de uitvoering vordert?

Als het een vaste vorm heeft: LangGraph. Als dat niet zo is, wil je een harness, en dan is de onderscheidende factor wat dat harness doet met je contextvenster bij stap veertig. Dat is waardevol om te meten voordat je erop gaat bouwen.

Met npx @truefoundry/trueforge heb je binnen ongeveer een minuut een werkende agent, of bekijk hoe TrueForge omgaat met context bij langdurige uitvoeringen.