Ontdek hoe de middleware-architectuur van LangChain 1.0 een revolutie teweegbrengt in agentontwikkeling, waardoor ontwikkelaars krachtige, uitbreidbare deep agents kunnen bouwen met planningsmogelijkheden, bestandsystemen en sub-agentfunctionaliteiten.
FlowHunt gebruikt de LangChain-bibliotheek aan de achterkant en in deze blogpost verken ik LangChain’s middleware-architectuur en hoe deze ons in staat stelt geavanceerdere AI-agenten te bouwen. De evolutie van AI-agenten bevindt zich op een kritisch kantelpunt. Nu taalmodellen steeds capabeler worden, groeit de vraag naar geavanceerde agentarchitecturen die complexe, meerstaps workflows aankunnen. LangChain 1.0 introduceert een paradigmawisseling in hoe ontwikkelaars agenten bouwen via zijn innovatieve middleware-architectuur, waarmee onze benadering van agentuitbreidbaarheid en compositie fundamenteel verandert. Deze uitgebreide gids onderzoekt de volledige herschrijving van deep agents bovenop LangChain 1.0 en belicht hoe middleware agentontwikkeling transformeert van een starre, monolithische aanpak naar een flexibel, samenstelbaar systeem waarmee ontwikkelaars krachtige agenten kunnen bouwen die zijn afgestemd op hun specifieke behoeften.
Voordat we de technische architectuur induiken, is het belangrijk te begrijpen wat deep agents onderscheidt van conventionele tool-calling systemen. In de kern zijn deep agents geavanceerde tool-calling loops die zijn uitgebreid met specifieke ingebouwde mogelijkheden waarmee ze complexe, meerstaps workflows met minimale menselijke tussenkomst aankunnen. Waar eenvoudige tool-calling agents taken sequentieel uitvoeren door tools aan te roepen en resultaten te verwerken, voegen deep agents een intelligentie- en structuurniveau toe dat hun aanpak van probleemoplossing fundamenteel verandert.
De basis van deep agents rust op vier cruciale pijlers. Ten eerste maken planningsmogelijkheden het agenten mogelijk gestructureerde takenlijsten te maken en te volgen, waardoor complexe taken worden opgesplitst in beheersbare stappen vóór uitvoering. Deze planningsfase is essentieel omdat het de agent in staat stelt het volledige proces te overzien, afhankelijkheden te identificeren en de volgorde van handelingen te optimaliseren. Ten tweede biedt bestandsysteemtoegang agenten permanente opslag om context op te slaan, zodat ze informatie in bestanden kunnen opslaan voor later gebruik in plaats van alles in de gespreksgeschiedenis te bewaren. Dit is vooral waardevol voor het beheren van grote hoeveelheden data of het behouden van status over meerdere bewerkingen. Ten derde stelt sub-agent spawning de hoofdagent in staat werk te delegeren aan gespecialiseerde sub-agenten voor geïsoleerde taken, wat zorgt voor een hiërarchische structuur die de efficiëntie verbetert en domeinspecifieke expertise mogelijk maakt. Tot slot bieden gedetailleerde systeemaanwijzingen uitgebreide instructies voor het effectief gebruiken van deze tools, zodat de agent niet alleen weet welke tools beschikbaar zijn, maar ook wanneer en hoe deze optimaal in te zetten.
Deze mogelijkheden zijn van onschatbare waarde gebleken in productieomgevingen zoals Manus en Cloud Code, waar agenten complexe workflows moeten navigeren, grote hoeveelheden context moeten beheren en slimme beslissingen moeten nemen over taakdelegatie. Het doel van het deep agents-pakket is om deze geavanceerde architectuur breed toegankelijk te maken, zodat ontwikkelaars eenvoudig krachtige agenten kunnen bouwen zonder het wiel opnieuw uit te vinden of elk implementatiedetail te hoeven begrijpen.
De traditionele manier om agenten te bouwen bestond uit het creëren van monolithische structuren waarin alle functionaliteit—planning, toolbeheer, statusafhandeling en prompt engineering—nauw verweven zaten in één codebase. Deze aanpak veroorzaakte verschillende problemen: het uitbreiden van agenten vereiste aanpassingen aan de kernlogica, het hergebruiken van componenten tussen verschillende agenten was lastig en het testen van individuele functies in isolatie was bijna onmogelijk. Ontwikkelaars accepteerden beperkingen of moesten enorme refactorings uitvoeren om nieuwe mogelijkheden toe te voegen.
LangChain 1.0 pakt deze uitdagingen aan met een revolutionair concept: middleware. Middleware betekent een paradigmawisseling in agentarchitectuur en introduceert een stapelbare abstractie waarmee ontwikkelaars agentmogelijkheden als bouwstenen kunnen samenstellen. In plaats van de kern van de agentloop te wijzigen, onderschept en verrijkt middleware specifieke punten in de uitvoeringsstroom van de agent, wat zorgt voor een heldere scheiding van verantwoordelijkheden en maximale herbruikbaarheid. Deze architecturale innovatie verandert agentontwikkeling van een monolithische alles-of-niets aanpak naar een modulair, samenstelbaar systeem waarin elke functionaliteit onafhankelijk kan worden ontwikkeld, getest en geïmplementeerd.
Het mooie van middleware zit in de stapelbaarheid. Ontwikkelaars kunnen meerdere middlewarecomponenten definiëren en deze opeenvolgend toepassen, waarbij elke laag eigen statusuitbreidingen, tools en systeemaanpassingen toevoegt. Dit betekent dat één agent kan profiteren van planningsmogelijkheden, bestandsysteemtoegang, sub-agent spawning en aangepaste domeinspecifieke uitbreidingen—alles naadloos samengevoegd. De volgorde van middlewaretoepassing is van belang, omdat elke laag voortbouwt op de vorige, wat een cumulatief effect geeft en resulteert in een zeer capabele agent.
Om middleware te begrijpen, moet je weten hoe het de fundamentele ReAct (Reasoning + Acting) agentloop aanpast. Het ReAct-patroon, inmiddels de standaard voor tool-calling agents, houdt in dat het model redeneert over welke actie te ondernemen, deze uitvoert via een tool, het resultaat observeert en deze cyclus herhaalt tot de taak voltooid is. Middleware vervangt deze loop niet, maar verrijkt hem op strategische momenten.
Middleware werkt via drie primaire mechanismen. Ten eerste breidt het het statuschema uit door nieuwe sleutels en datastructuren toe te voegen die de agent kan gebruiken en aanpassen. Zo kan elke middlewarecomponent zijn eigen status beheren zonder de andere te beïnvloeden. Ten tweede voegt het nieuwe tools toe aan de gereedschapskist van de agent, zodat het model meer mogelijkheden krijgt om zijn doelen te bereiken. Ten derde wijzigt het het modelverzoek, meestal door aangepaste instructies toe te voegen aan de systeemaanwijzing die uitleggen hoe en wanneer de nieuwe tools te gebruiken.
Deze drieluikbenadering zorgt dat middleware-uitbreidingen volledig en goed geïntegreerd zijn. Alleen een tool toevoegen, zonder de status uit te breiden of instructies te geven, zou ineffectief zijn—het model zou niet weten hoe of wanneer het de tool moet gebruiken. Door alle drie mechanismen te combineren, creëert middleware een samenhangende verbetering die het model effectief kan benutten.
De planningsmiddleware is een goed voorbeeld van hoe middlewarearchitectuur geavanceerde agentmogelijkheden mogelijk maakt. Deze middleware breidt het statuschema van de agent uit met een takenlijst, een eenvoudige maar krachtige datastructuur waarmee agenten een gestructureerd actieplan kunnen bijhouden. De implementatie is elegant in zijn eenvoud: de middleware voegt één sleutel toe aan het statuschema, maar deze sleutel ontsluit aanzienlijke mogelijkheden.
Om het planningshulpmiddel effectief te maken, biedt de middleware een write-to-dos tool waarmee het model de takenlijst kan maken, bijwerken en beheren. Wanneer de agent een complexe taak tegenkomt, kan hij deze tool gebruiken om de taak op te delen in kleinere, beter beheersbare stappen. In plaats van alles in één keer op te lossen, maakt de agent een plan, voert elke stap uit en past het plan aan naarmate hij vordert. Deze gestructureerde aanpak biedt meerdere voordelen: de redenatie van de agent wordt transparant en controleerbaar, fouten kunnen beter worden opgevangen (als een stap faalt, kan de agent de resterende stappen aanpassen) en vaak is de uitvoering efficiënter omdat de agent het volledige proces vooraf heeft doordacht.
Cruciaal is dat de planningsmiddleware niet alleen een tool toevoegt—het wijzigt ook de systeemaanwijzing met gedetailleerde instructies voor het effectief inzetten van de write-to-dos tool. Deze instructies leggen uit wanneer planning gepast is, hoe een goed plan te structureren en hoe het plan aan te passen naarmate de agent voortgang boekt. Deze verbetering van de systeemaanwijzing is essentieel omdat het het gedrag van het model stuurt en ervoor zorgt dat het planningshulpmiddel strategisch wordt ingezet.
Waar de planningsmiddleware zich richt op taakdecompositie, pakt de bestandsysteemmiddleware een ander, even belangrijk probleem aan: contextbeheer en het behouden van status over meerdere bewerkingen. De bestandsysteemmiddleware breidt de status van de agent uit met een files dictionary, waarmee een virtueel bestandssysteem wordt gecreëerd dat de agent kan lezen en beschrijven.
In tegenstelling tot de planningsmiddleware, die één tool biedt, levert de bestandsysteemmiddleware meerdere tools voor verschillende bestandsoperaties. De agent kan bestanden opvragen om te zien wat beschikbaar is, bestanden lezen om informatie in context te laden, nieuwe bestanden schrijven om informatie op te slaan en bestaande bestanden bewerken om opgeslagen data te wijzigen. Deze multihulpmiddelbenadering weerspiegelt de realiteit dat bestandsinteracties divers zijn en voor verschillende scenario’s verschillende handelingen vereisen.
De bestandsysteemmiddleware is vooral waardevol voor het beheren van grote hoeveelheden data of het behouden van status over meerdere handelingen. In plaats van alles in de gespreksgeschiedenis te bewaren (wat veel tokens kost en contextlimieten kan overschrijden), kan de agent informatie in bestanden opslaan en die ophalen wanneer nodig. Bijvoorbeeld: een agent die aan een onderzoeksproject werkt kan bevindingen in bestanden schrijven, deze per onderwerp ordenen en relevante bestanden ophalen bij het trekken van conclusies. Deze aanpak verbetert de efficiëntie aanzienlijk en stelt agenten in staat met veel grotere datasets te werken dan mogelijk zou zijn als alles in het contextvenster moest passen.
Net als de planningsmiddleware bevat de bestandsysteemmiddleware aangepaste systeemaanwijzingen die uitleggen hoe het bestandsysteem effectief te benutten. Deze aanwijzingen geven advies over wanneer informatie in bestanden te schrijven, hoe bestanden logisch te ordenen voor eenvoudige terughaalbaarheid en best practices voor het beheren van het virtuele bestandssysteem.
De sub-agent middleware is het meest geavanceerde onderdeel van de deep agents-architectuur. Deze middleware stelt de hoofdagent in staat gespecialiseerde sub-agenten te genereren voor geïsoleerde taken, wat een hiërarchische structuur oplevert die de efficiëntie verhoogt en domeinspecifieke expertise mogelijk maakt. De implementatie is complexer dan die van de plannings- of bestandsysteemmiddleware, omdat er meerdere scenario’s en configuraties worden ondersteund.
In de kern biedt de sub-agent middleware een task tool waarmee de hoofdagent werk aan sub-agenten kan delegeren. Wanneer de hoofdagent besluit dat een taak door een sub-agent moet worden uitgevoerd, roept hij de task tool aan, geeft aan welke sub-agent de taak moet oppakken en draagt relevante informatie over. De sub-agent voert de taak uit en geeft een uitgebreide respons terug aan de hoofdagent. Dit delegatiemodel heeft diverse voordelen: context wordt geïsoleerd (de sub-agent ziet alleen informatie die relevant is voor zijn taak), specialisatie wordt mogelijk (verschillende sub-agenten kunnen andere tools en prompts hebben) en de uitvoering is vaak schoner en efficiënter.
De sub-agent middleware ondersteunt twee primaire use cases voor het creëren van sub-agenten. De eerste is contextisolatie, waarbij een algemene sub-agent dezelfde tools krijgt als de hoofdagent maar een smalle, gerichte taak krijgt. De sub-agent rondt deze taak af en retourneert een schone, volledige respons zonder tussenliggende toolcalls of context die de gespreksgeschiedenis van de hoofdagent zou vervuilen. Deze aanpak bespaart tokens en tijd door onnodige contextaccumulatie te vermijden. De tweede use case is domeinspecialisatie, waarbij een sub-agent wordt aangemaakt met een aangepaste prompt en een specifieke subset aan tools, afgestemd op een bepaald domein of taaktype. Zo kan een onderzoeksagent een sub-agent hebben die is gespecialiseerd in literatuuronderzoek met toegang tot academische databases, terwijl een andere sub-agent is gespecialiseerd in data-analyse met toegang tot statistische tools.
De middleware ondersteunt twee manieren om sub-agenten te definiëren. Tool-calling sub-agenten worden van nul opgebouwd met een eigen prompt en een specifieke lijst aan tools. Deze sub-agenten kunnen totaal andere tools hebben dan de hoofdagent, wat echte specialisatie mogelijk maakt. Ontwikkelaars kunnen ook een eigen model specificeren voor elke sub-agent, zodat voor verschillende taken verschillende modellen kunnen worden ingezet. Aangepaste sub-agenten bieden nog meer flexibiliteit doordat ontwikkelaars direct bestaande LangGraph-graphs als sub-agent kunnen toevoegen. Dit is vooral waardevol voor ontwikkelaars die al geavanceerde agentworkflows hebben gebouwd en deze als sub-agent willen inzetten.
Belangrijk is dat sub-agenten ook middleware ontvangen, zodat ze profiteren van planning, bestandsysteemtoegang en andere uitbreidingen. Dit betekent dat sub-agenten niet beperkt zijn tot eenvoudige tool-calling—ze kunnen net zo geavanceerd zijn als de hoofdagent, met eigen planningsmogelijkheden, bestandsysteemtoegang en zelfs hun eigen sub-agenten.
Naarmate agenten langere gesprekken voeren en complexere taken afhandelen, wordt het contextvenster een kritische beperking. De samenvattingsmiddleware pakt deze uitdaging aan door context automatisch te beheren wanneer deze te groot wordt. Deze middleware bewaakt de gespreksgeschiedenis en wanneer het aantal tokens de limiet van het contextvenster nadert, comprimeert hij de geschiedenis automatisch door oudere berichten samen te vatten en recente te behouden.
De samenvattingsmiddleware is essentieel voor productieagenten die context over langere gesprekken moeten behouden. Zonder deze middleware zouden agenten uiteindelijk de contextlimiet bereiken en toegang tot belangrijke historische informatie verliezen. Dankzij de samenvatting blijft de agent zich bewust van eerdere interacties binnen de tokenlimiet. De middleware balanceert intelligent de noodzaak om recente context te behouden (vaak het meest relevant) met de mogelijkheid om oudere context samen te vatten (wat gecomprimeerd kan worden zonder cruciale informatie te verliezen).
Deze aanpak van contextbeheer weerspiegelt een breder principe in agentdesign: context is een kostbare hulpbron die zorgvuldig beheerd moet worden. Elke token die aan context wordt besteed, kan niet voor redenatie of tooloutput worden gebruikt. Door context automatisch samen te vatten wanneer nodig, zorgt de samenvattingsmiddleware dat agenten efficiënt blijven werken, ook in langlopende scenario’s.
Voor bedrijfskritische toepassingen waarin agenten gevoelige tools moeten aanroepen (zoals het versturen van e-mails, escaleren van issues of financiële transacties uitvoeren), biedt de human-in-the-loop middleware essentiële waarborgen. Deze middleware stelt ontwikkelaars in staat te specificeren welke tools onderbroken moeten worden vóór uitvoering, zodat mensen toolcalls kunnen beoordelen en goedkeuren (of aanpassen) voordat ze worden uitgevoerd.
De human-in-the-loop middleware accepteert een toolconfiguratie die aangeeft welke tools onderbroken moeten worden en welke acties mensen op deze toolcalls kunnen uitvoeren. Bijvoorbeeld: voordat een gevoelige tool een e-mail verstuurt, kunnen ontwikkelaars de middleware zo configureren dat mensen de actie kunnen goedkeuren, parameters kunnen bewerken of feedback kunnen geven aan de agent over wat anders moet. Dit creëert een samenwerkende workflow waarin de agent redenatie en planning afhandelt, maar mensen de controle behouden over kritische acties.
Deze middleware laat zien hoe de middleware-architectuur ontwikkelaars in staat stelt geavanceerde governance- en veiligheidsfuncties toe te voegen zonder de kernlogica van de agent te wijzigen. Verschillende toepassingen stellen verschillende eisen aan menselijke controle en de middlewarebenadering stelt elke toepassing in staat het juiste niveau van menselijke betrokkenheid te configureren.
Hoewel LangChain 1.0 diverse ingebouwde middlewarecomponenten biedt, ligt de echte kracht van de middleware-architectuur in de uitbreidbaarheid. Ontwikkelaars kunnen aangepaste middleware maken door de basisclass voor agent-middleware uit te breiden, zodat ze nieuwe statuswaarden, tools en systeemaanpassingen kunnen toevoegen die specifiek zijn voor hun eigen use case.
De ontwikkeling van custom middleware volgt hetzelfde patroon als de ingebouwde middleware: breid het statuschema uit met nieuwe sleutels, voeg tools toe die op die status werken en pas de systeemaanwijzing aan met instructies voor het gebruik van de nieuwe tools. Dit consistente patroon maakt het eenvoudig om nieuwe middlewarecomponenten te ontwikkelen die naadloos integreren met bestaande.
Een ontwikkelaar die bijvoorbeeld een agent voor klantenservice bouwt, kan custom middleware maken die een klantendatabase-tool toevoegt voor het opzoeken van klantinformatie, een ticketbeheertool voor het aanmaken en bijwerken van supporttickets, en een kennisbanktool voor het ophalen van relevante documentatie. Deze custom middleware breidt de mogelijkheden van de agent uit op een manier die specifiek is voor klantenservice, terwijl toch wordt geprofiteerd van de planning-, bestandsysteem- en sub-agentmogelijkheden van de ingebouwde middleware.
Doordat custom middleware mogelijk is, zijn ontwikkelaars nooit beperkt tot de ingebouwde mogelijkheden. Heeft een agent een specifieke tool of statusmanagement nodig, dan kan dat als middleware worden geïmplementeerd en naadloos met de rest van de agentarchitectuur worden geïntegreerd.
Hoewel LangChain 1.0 het architecturale fundament biedt voor het bouwen van geavanceerde agenten, tillen platforms zoals FlowHunt agentontwikkeling naar een hoger niveau door een no-code interface te bieden voor het bouwen, uitrollen en beheren van AI-agenten. FlowHunt’s AI Agent-component benut de principes van middleware-architectuur om ontwikkelaars in staat te stellen krachtige agenten te creëren zonder te hoeven programmeren.
De benadering van FlowHunt sluit perfect aan bij de middlewarefilosofie: samenstelbaarheid, uitbreidbaarheid en gebruiksgemak. In plaats van dat ontwikkelaars zich moeten verdiepen in de details van middleware-implementatie, biedt FlowHunt een visuele interface waarin agentmogelijkheden kunnen worden samengesteld door componenten te koppelen. Het platform verzorgt de onderliggende middleware-orkestratie, zodat ontwikkelaars zich kunnen richten op het definiëren van het gewenste gedrag van hun agent in plaats van de implementatie.
Agenten in FlowHunt kunnen worden geconfigureerd met planningsmogelijkheden, bestandsysteemtoegang, sub-agent spawning en custom tools—allemaal via een intuïtieve visuele interface. Dit democratiseert agentontwikkeling, zodat ontwikkelaars zonder diepgaande kennis van LangChain of agentarchitectuur toch geavanceerde agenten kunnen bouwen. Daarnaast biedt FlowHunt functies als uitgebreide agentlogs, geschiedenistracking en kostenbeheer waarmee ontwikkelaars het gedrag van hun agenten kunnen monitoren en optimaliseren.
Ontdek hoe FlowHunt je AI-content- en SEO-workflows automatiseert — van onderzoek en contentgeneratie tot publicatie en analyse — alles op één plek.
De theorie achter middlewarearchitectuur kennen is waardevol, maar de echte kracht blijkt in de praktijk. Een deep agent maken met LangChain 1.0 doe je met de create_deep_agent functie, die een kant-en-klare interface biedt voor het samenstellen van agenten met alle hierboven besproken mogelijkheden.
De create_deep_agent-functie accepteert enkele belangrijke parameters. Ontwikkelaars geven tools op waar de agent toegang toe moet hebben, aangepaste instructies die het gedrag en de doelen van de agent bepalen, en sub-agenten waaraan de hoofdagent werk kan delegeren. De functie gebruikt vervolgens de agent builder om de agent te bouwen door de juiste middleware in volgorde toe te passen.
De agent builder is waar de magie gebeurt. Het begint met het selecteren van een model (standaard Claude Sonnet 3.5, maar aanpasbaar naar elk ondersteund model) en past dan de middleware in een specifieke volgorde toe. De planningsmiddleware wordt als eerste toegepast, waarmee de status wordt uitgebreid met een takenlijst en de write-to-dos tool wordt toegevoegd. Daarna volgt de bestandsysteemmiddleware, die bestandsysteemtools en status toevoegt. De sub-agent middleware wordt als derde toegepast, zodat taakdelegatie mogelijk is. Tot slot wordt de samenvattingsmiddleware toegepast voor contextbeheer.
Deze sequentiële toepassing van middleware is cruciaal: elke laag bouwt voort op de vorige, wat een cumulatief effect oplevert. De systeemaanwijzing wordt in volgorde uitgebreid met instructies van elke middleware, zodat het model uitvoerige begeleiding krijgt over hoe alle mogelijkheden te benutten. Het statuschema groeit met elke middleware, zodat de agent verschillende soorten status kan behouden. De toolset breidt uit met elke middleware, waardoor het model meer opties krijgt om zijn doelen te bereiken.
Ontwikkelaars kunnen dit proces aanpassen door te kiezen welke middleware ze toepassen. Heeft een agent geen bestandsysteemtoegang nodig, dan kan de bestandsysteemmiddleware worden weggelaten. Heeft een agent geen sub-agenten nodig, dan kan die middleware worden overgeslagen. Deze flexibiliteit zorgt ervoor dat agenten precies die mogelijkheden krijgen die ze nodig hebben, zonder onnodige overhead.
Naarmate agenttoepassingen geavanceerder worden, moeten ontwikkelaars vaak meerdere agenten orkestreren die samenwerken om complexe doelen te bereiken. De middlewarearchitectuur maakt elegante oplossingen voor multi-agent orkestratie mogelijk via het sub-agentsysteem.
Een krachtig patroon is hiërarchische delegatie, waarbij een hoofdagent een complexe taak opdeelt in sub-taken en elke sub-taak delegeert aan een gespecialiseerde sub-agent. Bijvoorbeeld: een onderzoeksagent delegeert literatuuronderzoek aan de ene sub-agent, data-analyse aan een andere en synthese aan een derde. Elke sub-agent is geoptimaliseerd voor zijn specifieke taak, met aangepaste prompts en tools. De hoofdagent coördineert de algehele workflow en zorgt dat sub-agenten in de juiste volgorde werken en hun outputs goed geïntegreerd worden.
Een ander patroon is parallelle uitvoering, waarbij meerdere sub-agenten gelijktijdig aan verschillende aspecten van een probleem werken. De huidige implementatie verwerkt sub-agenten sequentieel, maar de architectuur ondersteunt uitvoeringspatronen waarin meerdere sub-agenten worden aangemaakt en hun resultaten worden samengevoegd. Dit is vooral waardevol voor taken die in onafhankelijke sub-taken kunnen worden opgesplitst.
Een derde patroon is iteratieve verfijning, waarbij een hoofdagent sub-agenten laat starten om eerste oplossingen te genereren en vervolgens hun output gebruikt om de aanpak te verfijnen en extra sub-agenten voor diepere analyse te laten werken. Dit patroon is nuttig voor complexe probleemscenario’s waarin meerdere iteraties van analyse en verfijning tot betere oplossingen leiden.
Deze patronen laten zien hoe de middlewarearchitectuur geavanceerde multi-agentensystemen mogelijk maakt zonder dat ontwikkelaars complexe orkestratielogica van de grond af hoeven op te bouwen. De sub-agent middleware verzorgt de mechaniek van delegatie en communicatie, zodat ontwikkelaars zich kunnen richten op het definiëren van de workflow en de mogelijkheden van elke agent.
Een van de meest praktische voordelen van de deep agents-architectuur is het effect op token-efficiëntie en kostenoptimalisatie. Door planning, bestandsysteemtoegang en sub-agentdelegatie te combineren kunnen deep agents complexe taken uitvoeren met aanzienlijk minder tokens dan eenvoudige agenten.
Planning vermindert het tokengebruik doordat agenten workflows vooraf doordenken, waardoor verspilling door eindeloos proberen en teruggaan wordt voorkomen. In plaats van verschillende benaderingen te proberen en te leren van fouten, kan de agent vooraf een efficiënte route naar de oplossing uitdenken. Bestandsysteemtoegang vermindert het tokengebruik doordat agenten context naar permanente opslag kunnen offloaden in plaats van alles in de gespreksgeschiedenis te bewaren. Informatie die niet direct nodig is kan in bestanden worden opgeslagen en later worden opgehaald, waardoor het actieve contextvenster slank blijft. Sub-agentdelegatie vermindert het tokengebruik door context te isoleren—sub-agenten zien alleen informatie die relevant is voor hun taak, zodat geen onnodige context wordt meegenomen die tokens zou kosten.
De samenvattingsmiddleware optimaliseert het tokengebruik verder door automatisch de gespreksgeschiedenis samen te vatten wanneer deze te groot wordt. In plaats van toegang tot historische informatie te verliezen of contextlimieten te overschrijden, vat de middleware oudere berichten samen, waarbij de essentie behouden blijft en tokens vrijkomen voor huidige redenatie.
Voor organisaties die agenten op schaal inzetten, vertaalt deze token-efficiëntie zich direct in kostenbesparingen. Een agent die 30% minder tokens gebruikt voor dezelfde taak, levert 30% lagere API-kosten op. Opgeteld over duizenden agentuitvoeringen levert dit aanzienlijke besparingen op.
De middlewarearchitectuur biedt een duidelijk pad voor toekomstige uitbreidingen en verbeteringen. Wanneer nieuwe mogelijkheden ontstaan of nieuwe use cases worden ontdekt, kunnen ontwikkelaars deze als middleware implementeren zonder bestaande agenten te verstoren. Dit maakt agenttoepassingen toekomstbestendig en maakt snelle iteratie op nieuwe features mogelijk.
Als er bijvoorbeeld een nieuwe mogelijkheid voor realtime websearch verschijnt, kunnen ontwikkelaars die als middleware implementeren die een zoektool en passende systeemaanwijzingen toevoegt. Bestaande agenten profiteren direct van deze nieuwe mogelijkheid door eenvoudigweg de zoekmiddleware toe te voegen aan hun configuratie. Evenzo, als er nieuwe modellen beschikbaar komen met andere mogelijkheden of kostenprofielen, kunnen agenten worden geüpdatet naar de nieuwe modellen zonder aanpassingen aan de middlewarearchitectuur.
Deze uitbreidbaarheid maakt het ook mogelijk voor de community om nieuwe middlewarecomponenten bij te dragen. Naarmate ontwikkelaars nuttige patronen en mogelijkheden ontdekken, kunnen ze hun middleware-implementaties delen, wat leidt tot een ecosysteem van herbruikbare agentverbeteringen. Deze samenwerkende benadering versnelt innovatie en stelt de agentontwikkelgemeenschap in staat collectief krachtigere en capabelere agenten te bouwen.
De herschrijving van deep agents bovenop de middlewarearchitectuur van LangChain 1.0 betekent een fundamentele stap vooruit in hoe ontwikkelaars AI-agenten bouwen. Door een stapelbare, samenstelbare abstractie voor agentverbeteringen te introduceren, transformeert LangChain 1.0 agentontwikkeling van een monolithische alles-of-niets aanpak naar een modulair, flexibel systeem waarin mogelijkheden kunnen worden gecombineerd om agenten te creëren die perfect aansluiten bij specifieke use cases. De planningsmiddleware maakt gestructureerde taakuitsplitsing mogelijk, de bestandsysteemmiddleware biedt contextbeheer en persistentie, de sub-agentmiddleware maakt delegatie en specialisatie mogelijk en de samenvattingsmiddleware beheert beperkingen van het contextvenster. Aangepaste middleware stelt ontwikkelaars in staat agenten uit te breiden met domeinspecifieke mogelijkheden, terwijl platforms zoals FlowHunt agentontwikkeling democratiseren door no-code interfaces te bieden voor het bouwen van geavanceerde agenten. Deze architectuur maakt agenten niet alleen krachtiger en efficiënter, maar ook beter onderhoudbaar, testbaar en toekomstbestendig. Naarmate AI-agenten een steeds centralere rol spelen in bedrijfsvoering, biedt de middlewaregebaseerde architectuur van LangChain 1.0 het fundament voor de volgende generatie intelligente, autonome systemen.
Deep agents zijn geavanceerde tool-calling loops die zijn uitgebreid met specifieke ingebouwde mogelijkheden: planningshulpmiddelen met takenlijsten, bestandsysteemtoegang voor contextoffloading, de mogelijkheid om sub-agenten te genereren voor geïsoleerde taken, en gedetailleerde systeemaanwijzingen. In tegenstelling tot eenvoudige tool-calling agents die taken sequentieel uitvoeren, kunnen deep agents complexe workflows beheren, de status over meerdere bewerkingen behouden en werk delegeren aan gespecialiseerde sub-agenten.
Middleware in LangChain 1.0 is een stapelbare abstractie die de kern van de ReAct-agentloop aanpast. Het stelt ontwikkelaars in staat het statuschema van de agent uit te breiden, nieuwe tools toe te voegen en systeemaanwijzingen aan te passen zonder de volledige agentlogica te herschrijven. Middleware is cruciaal omdat het samengestelde, herbruikbare agentverbeteringen mogelijk maakt die in elke volgorde gecombineerd kunnen worden om krachtige, gespecialiseerde agenten te creëren.
De planningsmiddleware breidt de status van de agent uit met een takenlijst en biedt een write-to-dos-tool. Hierdoor kunnen agenten complexe taken opdelen in beheersbare stappen, een duidelijk actieplan behouden en voortgang bijhouden. De middleware bevat ook aangepaste systeemaanwijzingen die het model instrueren over het effectief gebruiken van het planningshulpmiddel, zodat de agent gestructureerde plannen maakt en volgt.
Sub-agenten zijn gespecialiseerde agenten die door de hoofdagent worden aangemaakt om geïsoleerde, gefocuste taken af te handelen. Er zijn twee hoofdredenen om sub-agenten te creëren: (1) om context te isoleren—door een sub-agent een beperkte taak te geven en een schone respons terug te krijgen zonder tussenliggende toolcalls, wat tokens bespaart; en (2) om domeinspecifieke agenten te maken met aangepaste prompts en gespecialiseerde toolsets die zijn afgestemd op specifieke taken.
De samenvattingsmiddleware bewaakt de gespreksgeschiedenis en comprimeert deze automatisch wanneer het aantal tokens de limiet van het contextvenster nadert. Het vat oudere berichten samen terwijl het recente berichten behoudt, zodat de agent zich bewust blijft van eerdere interacties zonder de tokenlimiet te overschrijden. Dit is essentieel voor langlopende agenten die context over lange gesprekken moeten behouden.
Ja, absoluut. Deep agents zijn ontworpen om uitbreidbaar te zijn. Je kunt aangepaste middleware maken door de basisclass voor agent-middleware uit te breiden, zodat je nieuwe statuswaarden, tools en systeemaanpassingen kunt toevoegen. Zo kun je agenten volledig afstemmen op jouw specifieke use case, terwijl je profiteert van de bestaande deep agent-infrastructuur.
Viktor Zeman is mede-eigenaar van QualityUnit. Zelfs na 20 jaar leiding te hebben gegeven aan het bedrijf, blijft hij in de eerste plaats een software engineer, gespecialiseerd in AI, programmatische SEO en backend-ontwikkeling. Hij heeft bijgedragen aan tal van projecten, waaronder LiveAgent, PostAffiliatePro, FlowHunt, UrlsLab en vele anderen.
Creëer uitbreidbare, intelligente agenten met FlowHunt's intuïtieve platform. Automatiseer complexe workflows met planning, bestandsystemen en multi-agent orkestratie—geen code nodig.
Ontdek waarom vooraanstaande engineers afstand nemen van MCP-servers en verken drie bewezen alternatieven—CLI-gebaseerde benaderingen, scriptgebaseerde tools en...
Ontdek waarom Model Context Protocol (MCP) mogelijk niet de ideale abstractie is voor AI agents, en ontdek de superieure aanpak van code-executie die het tokenv...
LangChain is een open-source framework voor het ontwikkelen van applicaties aangedreven door Large Language Models (LLM’s), waarmee de integratie van krachtige ...
Cookie Toestemming
We gebruiken cookies om uw browse-ervaring te verbeteren en ons verkeer te analyseren. See our privacy policy.
