Agentische systemen voor productie met LangGraph, toolgebruik & evaluatie

Deze pagina beschrijft hoe LMXAI agentische systemen voor productie ontwerpt en bouwt: expliciete control flow in LangGraph, toolgebruik achter getypeerde schema's, retrieval met toegangscontrole, evaluatie vóór de release en tracing tijdens gebruik. De aanpak wordt geplaatst in het onderzoek naar de betrouwbaarheid van agents, waar benchmarks laten zien dat huidige modellen nog falen op taken met een lange horizon en meerdere beurten, en de pagina legt uit wanneer een agent het juiste ontwerp is en wat een opdracht oplevert.

Trefwoorden agentische systemen · LangGraph · toolgebruik · evaluatie · observability · MCP

LMXAI is een AI-engineeringstudio in de EU die agentische systemen voor productie ontwerpt en bouwt met LangGraph, gecontroleerd toolgebruik, retrieval, evaluatie en observability. De nadruk ligt niet op autonome demo's, maar op begrensde workflows die in echte bedrijfsomgevingen te testen, te monitoren en veilig te beheren zijn.

LMXAI is gevestigd in Leiden en werkt aan architectuur, backend-engineering, modelintegratie, RAG, inferentie en productoplevering, zodat de agentlaag wordt ontworpen samen met de systemen die hij echt moet gebruiken.

De moderne agentloop komt voort uit werk dat laat zien dat een taalmodel beter presteert op taken met meerdere stappen wanneer het redeneren afwisselt met acties op externe bronnen, zodat het kan plannen, uitzonderingen kan afhandelen en ontbrekende informatie kan verzamelen^[1]. Een systematisch overzicht ordent de systemen die op dat idee zijn gebouwd rond een gemeenschappelijk constructieraamwerk en bespreekt hoe ze worden geëvalueerd^[2].

Evaluatieresultaten verklaren waarom LMXAI de autonomie begrenst. AgentBench wijst over acht omgevingen zwak redeneren op lange termijn, zwakke besluitvorming en het slecht opvolgen van instructies aan als de belangrijkste obstakels voor bruikbare agents^[3]. Op τ-bench voltooiden de beste function-calling-agents minder dan de helft van de taken en waren ze inconsistent over herhaalde pogingen^[4]. De Berkeley Function Calling Leaderboard, die aanroepen structureel controleert, stelt vast dat modellen enkelvoudige aanroepen goed afhandelen, maar nog worstelen met geheugen, dynamische beslissingen en taken met een lange horizon^[5].

Toegang tot tools vergroot ook het aanvalsoppervlak: instructies die verborgen zitten in opgehaalde content kunnen een model sturen en toolaanroepen uitlokken zonder dat de aanvaller het systeem ooit direct aanspreekt^[6]. Deze bevindingen zijn de reden voor expliciete grafen, toolaanroepen die tegen een schema worden gecontroleerd, goedkeuringspoorten en evaluatie vóór de release.

Een productie-agent heeft meer nodig dan een LLM dat aan tools is gekoppeld. Er moet expliciete controle zijn over wat het model mag beslissen, waar het bij kan, hoe fouten worden afgehandeld en hoe kwaliteit wordt gemeten.

LMXAI behandelt een agentisch systeem doorgaans als zes samenhangende lagen:

1. Orkestratie — toestand, routering, retries, vertakkingen en deterministische stappen.
2. Modellaag — een of meer modellen, gekozen op taakkwaliteit, latency, privacy en kosten.
3. Tools — interne API's, zoeken, databases, documentservices, MCP-servers en bedrijfsacties.
4. Retrieval — relevante interne of externe kennis met bronvermelding en toegangscontrole.
5. Evaluatie — herhaalbare tests voor toolkeuze, taakvoltooiing, onderbouwing en foutgevallen.
6. Observability & governance — traces, logs, rechten, goedkeuringen en operationele metrics.

LangGraph is nuttig omdat we toestand en control flow daarmee expliciet kunnen maken, in plaats van de hele workflow in één lange prompt te verstoppen.

LMXAI gebruikt LangGraph waar een workflow baat heeft bij beslissingen van het model, maar toch engineeringcontrole nodig heeft.

Voorbeelden:

• een verzoek naar de juiste tool of kennisbron routeren;
• een complexe taak opdelen in begrensde stappen;
• extra bewijs ophalen als het eerste resultaat zwak is;
• goedkeuring eisen vóór een ingrijpende actie;
• tooloutput valideren voordat die de volgende node bereikt;
• escaleren naar een mens als aan voorwaarden voor zekerheid of beleid niet is voldaan.

Het doel is niet maximale autonomie. Het doel is de minimale autonomie die nodig is om de taak betrouwbaar op te lossen.

Bij tool calling begint een agent met echte systemen te werken, dus het ontwerp van tools is even belangrijk als het ontwerp van prompts.

LMXAI ontwerpt tools met:

• smalle, expliciete schema's;
• gevalideerde in- en output;
• afgebakende rechten;
• idempotentie waar acties opnieuw kunnen worden uitgevoerd;
• voorspelbare foutcontracten;
• controleerbaarheid van toolaanroepen;
• timeouts en terugvalgedrag;
• goedkeuringspoorten voor acties met grote impact.

Tools kunnen worden aangeboden via directe API's, interne servicewrappers of MCP als interoperabiliteit nuttig is. Het model mag nooit meer toegang krijgen dan de taak vraagt.

Agentische systemen moeten vaak kiezen tussen meerdere databronnen in plaats van één vaste vectorindex te bevragen. LMXAI kan combineren:

• dense en sparse retrieval;
• hybride zoeken;
• Elasticsearch of andere zakelijke zoekinfrastructuur;
• retrieval die rekening houdt met metadata en rechten;
• herschrijven en opdelen van zoekvragen;
• routering over meerdere indexen;
• verificatie van bronnen voordat een antwoord wordt gegenereerd.

Zo wordt retrieval een gecontroleerde relevantielaag in plaats van een generieke "zoektool".

Een agent is niet klaar omdat een paar handmatig geteste gesprekken goed gingen. LMXAI bouwt de evaluatie rond de beslissingen die het systeem echt moet nemen.

Afhankelijk van de toepassing kan evaluatie omvatten:

• het percentage voltooide taken;
• de juiste toolkeuze;
• de nauwkeurigheid van toolargumenten;
• recall en onderbouwing van de retrieval;
• correcte bronvermelding;
• gedrag bij weigeren en escaleren;
• het aantal loops en retries;
• latency en tokenkosten;
• regressietests bij wijzigingen in model of prompt.

Voor systemen met toolgebruik werkt LMXAI ook met evaluatiepatronen in benchmarkstijl, zoals function-calling-tests afgeleid van BFCL, gecombineerd met domeinspecifieke testsets die de echte workflows van de klant weerspiegelen.

Productie-agents hebben traces nodig die uitleggen wat er in een workflow gebeurde. LMXAI kan agentruns instrumenteren met technologieën als OpenTelemetry en Phoenix, zodat teams modelaanroepen, toolaanroepen, retrievalstappen, latency, fouten en tokengebruik kunnen inspecteren.

Dat is vooral belangrijk wanneer agents werken in gereguleerde domeinen of waar veel op het spel staat. Een team moet een modelfout kunnen onderscheiden van een retrievalfout, toolfout, rechtenprobleem of een bug in de orkestratie.

Een typisch systeem kan er zo uitzien:

Gebruiker of applicatie → API → LangGraph-workflow → model/router → retrieval + tools → validatie/goedkeuring → antwoord of bedrijfsactie

Over de hele workflow liggen identiteit, rechten, traces, evaluatie en beleidscontroles.

De uiteindelijke architectuur kan draaien op frontier-API's, zelf gehoste open modellen of een hybride opzet. LMXAI is modelonafhankelijk en bouwt ook soevereine inferentiestacks met vLLM en Kubernetes als dataresidentie of controle over de infrastructuur dat vereist.

LMXAI heeft productiesystemen gebouwd voor bedrijven, onderwijs en paramedische zorg, waaronder:

• zakelijke AI-werkplekken met soevereine inferentie;
• agentische workflows op LangGraph;
• MCP- en maatwerkintegraties van tools;
• RAG-systemen met zakelijke retrieval;
• multimodale fine-tuning voor toolgebruik;
• AI-gateways met streaming, isolatie en observability.

De engineeringstack omvat LangGraph, LangChain, MCP, FastAPI, Elasticsearch, vLLM, Kubernetes, OpenTelemetry en Phoenix.

Bekijk de agentische capaciteiten van LMXAI

Een agentische architectuur is nuttig wanneer een taak dynamische keuzes vraagt tussen tools, bronnen of workflowpaden. Ze is vaak overbodig wanneer een deterministische service, een vaste pipeline of een gewoon zoekendpoint het probleem betrouwbaarder oplost.

LMXAI begint daarom bij de bedrijfsworkflow en vraagt waar het redeneren van een model echt waarde toevoegt. Autonome complexiteit komt er alleen bij als die haar operationele kosten waard is.

Een productieopdracht kan omvatten:

• ontwerp van workflow en architectuur;
• implementatie in LangGraph;
• integratie van tools en MCP;
• retrievalarchitectuur;
• modelkeuze en routering;
• evaluatiedatasets en releasepoorten;
• observability en tracing;
• rechten en flows voor menselijke goedkeuring;
• deployment, loadtests en productierijp maken;
• documentatie en overdracht.

• Project agentische capaciteiten
• RAG en agents in productie
• Soevereine vLLM-deployment
• Fractional AI CTO

LMXAI kan een agentisch product van workflowontwerp naar productiearchitectuur, implementatie, evaluatie en deployment brengen, onder één engineeringeigenaar.

Bespreek uw agentische systeem met LMXAI