Hoe AI-agents Vaardigheden Daadwerkelijk Implementeren: Volledige Cross-Platform Vergelijking

Inleiding

Elk AI-agentframework staat voor dezelfde fundamentele vraag: hoe maak je een LLM ergens specifiek goed in? Het model zelf heeft brede algemene kennis, maar wanneer je het nodig hebt om een codereview uit te voeren, infrastructuur te implementeren of door Minecraft te navigeren—heeft het gespecialiseerde instructies, tooltoegang en domeincontext nodig.

Dit is het vaardigheidsinjectieprobleem. En elk groot framework lost het anders op.

Sommige platforms stoppen alles vooraf in de systeemprompt. Andere gebruiken lazy loading, waarbij mogelijkheden pas worden onthuld wanneer de agent ze nodig heeft. Een paar gebruiken vectordatabases om relevante vaardigheden op te halen op basis van semantische gelijkenis. De verschillen zijn niet academisch—ze beïnvloeden direct tokenkosten, agentbetrouwbaarheid en hoeveel vaardigheden een agent realistisch gezien kan beheren.

We hebben 11 grote AI-agentplatforms geanalyseerd om precies te begrijpen waar vaardigheden in de prompt terechtkomen, wanneer ze laden, wat ze kosten in tokens, en hoe ze overleven wanneer het contextvenster vol raakt. Dit is geen oppervlakkige functievergelijking. We hebben broncode, documentatie en architectuurdiagrammen doorgespit om de precieze injectiemechanismen van elk platform in kaart te brengen.

Hoofdvergelijkingstabel

Hier is het volledige overzicht voordat we in de details duiken.

Injectiemechanismen: Waar, Wanneer en Hoe

Persistentie, Tokenkosten en Always-On Gedrag

Klaar om uw bedrijf te laten groeien?

Start vandaag uw gratis proefperiode en zie binnen enkele dagen resultaten.

Demo aanvragen Inloggen

Wat “Vaardigheidsinjectie” Werkelijk Betekent

Voordat we in de vergelijking duiken, laten we de probleemruimte definiëren. Het contextvenster van een AI-agent—de totale tekst die het LLM bij elke aanroep ziet—heeft een vaste grootte. Elke token aan instructie, gespreksgeschiedenis, tooldefinitie en opgehaalde data concurreert om ruimte in dat venster.

Een “vaardigheid” in de agentcontext is elk gestructureerd pakket van expertise dat het gedrag van de agent verandert. Dit kan zijn:

• Instructies die de agent vertellen hoe een specifiek domein te benaderen (codereviews-richtlijnen, implementatiechecklist)
• Tooldefinities die de agent aanroepbare functies geven (API-integraties, bestandsbewerkingen)
• Few-shot-voorbeelden die de agent laten zien hoe goede output eruitziet
• Opgehaalde kennis uit vectordatabases of externe documenten

Het injectiemechanisme—waar en wanneer deze inhoud het context binnenkomt—bepaalt drie kritische eigenschappen:

1. Tokenefficiëntie: Hoeveel tokens verbruikt de vaardigheid, en worden die kosten betaald zelfs wanneer de vaardigheid niet nodig is?
2. Betrouwbaarheid: Zal de agent de vaardigheid consistent gebruiken wanneer relevant, of kan hij het signaal missen?
3. Schaalbaarheid: Hoeveel vaardigheden kan de agent benaderen voordat contextopzwelling de prestaties verslechtert?

Elk framework maakt andere afwegingen over deze drie dimensies. Laten we ze allemaal onderzoeken.

Het Injectiespectrum: Van Always-On tot On-Demand

Over alle 11 platforms heen vallen vaardigheidsinjectie-benaderingen langs een spectrum van “alles vooraf geladen” tot “niets geladen totdat het expliciet nodig is.”

Aan het ene uiteinde injecteren platforms zoals CrewAI, SuperAGI en CAMEL-AI de volledige inhoud van elke geactiveerde vaardigheid in elke LLM-aanroep. De agent heeft altijd zijn complete expertise beschikbaar. Eenvoudig, betrouwbaar, maar duur in tokens.

Aan het andere uiteinde gebruiken Claude Code, LangChain Deep Agents en OpenAI’s Responses API progressieve onthulling—de agent ziet bij het opstarten alleen vaardigheidsnamen en korte beschrijvingen, en volledige inhoud wordt on-demand geladen. Efficiënt, schaalbaar, maar vereist dat de agent herkent wanneer hij een vaardigheid nodig heeft.

In het midden gebruiken AutoGen Teachability en Voyager semantisch ophalen om alleen de meest relevante vaardigheden per beurt te injecteren, waardoor een dynamisch, contextgevoelig injectiepatroon ontstaat.

En dan zijn er unieke benaderingen: DSPy compileert geoptimaliseerde few-shot-voorbeelden offline en bakt ze permanent in moduleprompts. MetaGPT codeert vaardigheden als actiesjablonen die alleen activeren wanneer een specifieke rol overgaat naar een specifieke actie.

Laten we elk in detail bekijken.

Schrijf u in voor onze nieuwsbrief

Ontvang gratis de nieuwste tips, trends en aanbiedingen.

E-mailadres

Abonneren

Claude Code: Drielaags Progressieve Onthulling

Claude Code implementeert een van de meest geavanceerde vaardigheidsinjectiearchitecturen, met een drielaags progressief onthullingssysteem dat bewustzijn in balans brengt met tokenefficiëntie.

Laag 1: Altijd in Context

Bij sessiestart wordt de naam en beschrijving van elke beschikbare vaardigheid geïnjecteerd in een system-reminder-bericht—een metadatablok dat het model altijd ziet. Dit kost ruwweg 250 tekens per vaardigheid en verbruikt ongeveer 1% van het contextvensterbudget voor alle vaardigheidsbeschrijvingen samen (ongeveer 8K tekens als terugvalbudget, overschrijfbaar via de SLASH_COMMAND_TOOL_CHAR_BUDGET-omgevingsvariabele).

Op vergelijkbare wijze verschijnen uitgestelde tools—tools waarvan de volledige JSON-schema’s nog niet zijn geladen—als een naamlijst in system-reminder-blokken. Vanaf Claude Code v2.1.69 worden zelfs ingebouwde systeemtools zoals Bash, Read, Edit, Write, Glob en Grep uitgesteld achter ToolSearch, waardoor de systeemtoolcontext wordt teruggebracht van ongeveer 14–16K tokens naar ruwweg 968 tokens.

De agent ziet genoeg om te weten wat beschikbaar is zonder de tokenkosten van volledige definities te betalen.

Laag 2: Bij Activering

Wanneer een gebruiker een slash-commando typt (bijv. /commit) of het model automatisch een vaardigheid matcht op basis van de beschrijving, wordt de volledige SKILL.md-body geladen als conversatiebericht via de Skill tool. Deze body bevat de complete instructies—soms duizenden tokens aan gedetailleerde begeleiding.

Belangrijk detail: Shellvoorverwerking wordt eerst uitgevoerd (alle !command-richtlijnen in het vaardigheidsbestand worden uitgevoerd en hun uitvoer vervangt de richtlijn), en eenmaal geladen blijft de vaardigheidsbody in het gesprek voor de rest van de sessie.

Laag 3: On Demand

Aanvullende bronnen—referentiedocumenten, scripts, assetbestanden—worden alleen gelezen wanneer het model expliciet besluit de Read-tool te gebruiken om ze te benaderen. Deze worden nooit automatisch geladen.

Contextcompactiegedrag

Wanneer het gesprek de contextlimiet nadert en compactie wordt geactiveerd, koppelt Claude Code de meest recent aangeroepen vaardigheden opnieuw met een budget van 5K tokens per vaardigheid en een gecombineerd maximum van 25K. Meest recent aangeroepen vaardigheden krijgen prioriteit. Oudere vaardigheden kunnen volledig worden verwijderd.

Deze drielaagse architectuur betekent dat een agent met 20+ beschikbare vaardigheden minimale voorafkosten betaalt maar binnen één beurt volledige expertise over elk ervan kan benaderen.

CrewAI: Volledige Injectie in Elke Taakprompt

CrewAI kiest de tegenovergestelde benadering van progressieve onthulling. Wanneer een vaardigheid is geactiveerd voor een agent, wordt de volledige inhoud geïnjecteerd in elke taakprompt die de agent uitvoert.

Hoe Het Werkt

Vaardigheden in CrewAI zijn zelfstandige mappen, elk met een SKILL.md-bestand dat YAML-frontmatter bevat (naam, beschrijving, licentie, compatibiliteit, toegestane tools) en een markdown-body. Het vaardigheidssysteem maakt onderscheid tussen vaardigheden en tools: vaardigheden injecteren instructies en context die bepalen hoe de agent denkt, terwijl tools aanroepbare functies bieden voor acties.

Tijdens agentinitialisatie roept Agent.set_skills() discover_skills() aan om vaardigheidsmappen op metadataniveau te scannen, en vervolgens activate_skill() om volledige vaardigheidsbodies te lezen. Bij taakuitvoering roept _finalize_task_prompt() format_skill_context() aan voor elke geactiveerde vaardigheid en voegt alle geformatteerde vaardigheidsinhoud toe aan de taakprompt.

Het LLM ontvangt: [systeembericht] + [taakprompt + ALLE vaardigheidsbodies]

Tokenimplicaties

CrewAI legt een zachte waarschuwing op bij 50.000 tekens per vaardigheid maar geen harde limiet. De documentatie raadt aan om vaardigheden gefocust en beknopt te houden omdat grote promptinjecties de aandacht van het model verdunnen—een reëel probleem gezien onderzoek naar contextvervuiling.

De afweging is eenvoudig: de agent heeft altijd volledige expertise beschikbaar (hoge betrouwbaarheid), maar tokenkosten schalen lineair met het aantal vaardigheden per taak (lage efficiëntie). Voor agents met 1-2 gefocuste vaardigheden werkt dit goed. Voor agents die brede mogelijkheden nodig hebben, wordt het snel duur.

Geen Cross-Taak Persistentie

Elke taak krijgt een verse injectie. Er is geen ophoping van vaardigheidsinhoud over taken heen—wat eigenlijk een functie is, geen bug. Het betekent dat elke taak met een schone context begint, waardoor de verouderingsproblemen worden vermeden die sessiegerbaseerde persistentie kan creëren.

LangChain Deep Agents: Agent-Gestuurd Laden via SkillsMiddleware

LangChain Deep Agents implementeert een geavanceerd middleware-gebaseerd vaardigheidssysteem waarbij de agent zelf beslist wanneer volledige vaardigheidsinhoud wordt geladen—een echt progressief onthullingsmodel waarbij de agent de activering controleert.

De Drie Niveaus

Niveau 1 (Index): SkillsMiddleware analyseert alle SKILL.md-frontmatter bij opstart en injecteert een lichtgewicht index in de systeemprompt. Deze index bevat alleen namen en beschrijvingen, wat ongeveer 278 tokens per vaardigheid kost versus 3.302 tokens voor volledige inhoud.

Niveau 2 (Volledige Inhoud): Wanneer de agent bepaalt dat een vaardigheid relevant is, roept hij read_file() aan op het SKILL.md-pad van de vaardigheid. Dit is een reguliere toolaanroep—het framework injecteert de body niet; de agent neemt een bewuste beslissing om deze te laden. De volledige inhoud komt in de gespreksgeschiedenis als toolresultaat.

Niveau 3 (Verdieping): Ondersteunende materialen, referentiedocumenten en scripts worden alleen benaderd wanneer de agent ze expliciet leest.

Tokenefficiëntie in de Praktijk

Met 12 vaardigheden vermindert progressieve onthulling de context van ongeveer 30.000 tokens (alles geladen) naar ruwweg 600 tokens (alleen index), uitbreidend naar 2.000–5.000 wanneer relevante vaardigheden worden geladen voor een specifieke taak. Dat is een potentiële reductie van 83–98% in vaardigheidsgerelateerd tokenverbruik.

Meerdere vaardigheidsbronnen kunnen gelaagd worden, en bij naamconflicten wint de laatste bron. Bestanden groter dan 10 MB worden automatisch overgeslagen.

Het Belangrijkste Verschil met Claude Code

Waar Claude Code een speciale Skill tool gebruikt om het laden te activeren, hergebruikt Deep Agents de bestaande read_file-tool van de agent. Dit betekent dat het laadmechanisme transparant is—de agent leest vaardigheidsbestanden op dezelfde manier als elk ander bestand. Het nadeel is dat er geen speciaal compactiegedrag is: vaardigheidsinhoud die in de gespreksgeschiedenis komt, is onderworpen aan standaard LangChain-berichttrimming, zonder prioriteitsbehandeling.

OpenAI Responses API en Agents SDK: Platformbeheerd Uitgesteld Laden

OpenAI implementeert vaardigheidsinjectie via twee verschillende maar filosofisch gelijkgestemde mechanismen: het tool_search-tooltype van de Responses API en de ToolSearchTool van de Agents SDK.

Responses API: tool_search

Het tool_search-tooltype (beschikbaar op GPT-5.4+) stelt ontwikkelaars in staat grote tooloppervlakken uit te stellen tot runtime. Drie uitstelstrategieën zijn beschikbaar:

• Individueel functie-uitstel: @function_tool(defer_loading=True) — het model ziet de functienaam en beschrijving maar het parameterschema wordt uitgesteld. Bespaart tokens op parameterniveau.
• Namespace-uitstel: tool_namespace(name=..., description=..., tools=[...]) — groepeert functies onder één namespace. Het model ziet alleen de namespacenaam en beschrijving, wat aanzienlijk meer tokens bespaart.
• MCP-server-uitstel: HostedMCPTool(tool_config={..., "defer_loading": True}) — stelt volledige MCP-server-tooloppervlakken uit.

Wanneer het model bepaalt dat het een specifieke tool nodig heeft, doet het een tool_search-aanroep. De API retourneert 3-5 relevante tooldefinities, geïnjecteerd aan het einde van het contextvenster om promptcaching te behouden.

Agents SDK: ToolSearchTool

De Agents SDK biedt een programmatisch equivalent. Toolnamespaces worden geregistreerd maar niet geladen:

crm_tools = tool_namespace(
    name="crm",
    description="CRM management tools",
    tools=[...]
)
agent = Agent(tools=[*crm_tools, ToolSearchTool()])

Tijdens runtime ziet de agent alleen namespacenamen. Hij roept ToolSearchTool("crm") aan om de volledige schema’s te ontdekken en laden, en kan vervolgens individuele tools binnen die namespace aanroepen.

Geen Cross-Request Persistentie

Elke API-aanvraag is onafhankelijk. Ontdekte tools blijven niet bestaan over aanroepen heen. Dit is de meest stateless benadering in onze vergelijking—schoon, voorspelbaar, maar vereist herontdekking bij elke aanvraag als tools veranderen.

AutoGen Teachability: Semantisch Ophalen Per Beurt

De Teachability-mogelijkheid van AutoGen kiest een fundamenteel andere benadering dan elk ander framework in deze vergelijking. In plaats van statische vaardigheidsinhoud te injecteren, haalt het dynamisch relevante “memo’s” op uit een ChromaDB-vectordatabase bij elke afzonderlijke beurt.

De Ophaallus Per Beurt

Teachability registreert een hook op process_last_received_message die elk binnenkomend gebruikersbericht onderschept voordat de agent het verwerkt:

1. Een TextAnalyzerAgent extraheert sleutelconcepten uit het binnenkomende bericht
2. Deze concepten worden gebruikt om ChromaDB te bevragen (standaard met Sentence Transformer-embeddings)
3. De top-K meest relevante memo’s worden opgehaald (configureerbaar via max_num_retrievals, standaard 10)
4. Opgehaalde memo’s worden toegevoegd aan de berichttekst voordat de agent deze ziet

Cruciaal: het aangepaste bericht wordt niet opgeslagen in de gespreksgeschiedenis—alleen het originele bericht wordt bewaard. Dit voorkomt dat memo-inhoud zich over beurten heen opstapelt.

Leerlus

Nadat het LLM reageert, analyseert een tweede hook de respons op nieuwe lessen:

1. TextAnalyzerAgent identificeert nieuwe kennis in de respons
2. Nieuwe memo’s worden geëxtraheerd als sleutel-waardeparen (invoertekst → uitvoertekst)
3. Deze memo’s worden opgeslagen in ChromaDB, beschikbaar voor toekomstige beurten en sessies

Dit creëert een echte leerlus waarbij de agent in de loop van de tijd expertise opbouwt.

Cross-Sessie Persistentie

AutoGen Teachability is een van slechts drie platforms in onze vergelijking (naast Voyager en DSPy) die vaardigheden over sessies heen persistent maakt. De ChromaDB-database staat op schijf, wat betekent dat een agent kan leren van interacties op maandag en die kennis op vrijdag kan toepassen.

De recall_threshold-parameter (standaard 1,5) bepaalt hoe vergelijkbaar een bericht moet zijn met een opgeslagen memo voor ophaling, en reset_db kan het volledige geheugen wissen wanneer nodig.

Tokenefficiëntie

Aangezien alleen relevante memo’s per beurt worden geïnjecteerd (typisch 3-5), zijn de tokenkosten van nature begrensd, ongeacht hoe groot de memodatabase wordt. Een agent met 10.000 opgeslagen memo’s betaalt nog steeds alleen voor de handvol die het meest relevant is voor de huidige beurt.

Semantic Kernel: Plugin-Schema’s als Altijd Aanwezige Tooldefinities

Microsofts Semantic Kernel kiest een rechttoe-rechtaan benadering: plugins zijn verzamelingen van KernelFunction-objecten die bij de Kernel worden geregistreerd, en hun schema’s worden aan het LLM gepresenteerd als functieaanroep-tooldefinities.

Twee Injectiepaden

Functieaanroep: Wanneer ToolCallBehavior.AutoInvokeKernelFunctions is ingesteld, worden alle geregistreerde functies naar het LLM gestuurd als beschikbare tools in elke API-aanvraag. Het LLM beslist welke aan te roepen; Semantic Kernel regelt aanroep en resultaatroutering.

Promptsjablonen: De sjabloonsyntaxis van Semantic Kernel ({{plugin.function}}, Handlebars of Liquid) maakt het mogelijk functies inline aan te roepen tijdens promptrendering. Resultaten worden direct in de prompttekst ingebed voordat deze het LLM bereikt—een vorm van eager evaluatie in plaats van lazy toolaanroep.

Geen Progressieve Onthulling

Het schema van elke geregistreerde plugin wordt opgenomen in elke API-aanroep. Er is geen ingebouwde uitgestelde lading, namespacegroepereing of on-demand activering. De documentatie raadt expliciet aan alleen de plugins te importeren die nodig zijn voor een specifiek scenario om tokenverbruik en foutieve aanroepen te verminderen.

Dit maakt Semantic Kernel een van de meest voorspelbare platforms—je weet altijd precies waartoe de agent toegang heeft—maar het beperkt de schaalbaarheid. Een agent met 50 geregistreerde functies betaalt de volledige schemakosten bij elke aanroep.

Persistentie

Pluginregistratie is per Kernel-instantie en in-memory. Er is geen ingebouwd mechanisme voor cross-sessie vaardigheidspersistentie.

MetaGPT: Actiesjablonen Binnen Rolgebaseerde SOP’s

MetaGPT codeert vaardigheden niet als losstaande pakketten maar als actiesjablonen ingebed in Standard Operating Procedures (SOP’s) die rolgedrag sturen.

Rol- en Actiearchitectuur

Elke Role in MetaGPT heeft een personaprefix die in prompts wordt geïnjecteerd en een set Action-klassen. Elke Action bevat een LLM-proxy die wordt aangeroepen via aask(), die natuurlijke taal-promptsjablonen gebruikt om de LLM-aanroep te structureren.

Wanneer Role._act() vuurt, ondersteunt het drie reactiemodi:

• "react": Het LLM selecteert dynamisch acties in denk-handellussen
• "by_order": Acties worden sequentieel uitgevoerd in een vooraf bepaalde volgorde
• "plan_and_act": De agent plant eerst, voert vervolgens acties uit volgens het plan

Smal Injectievenster

Alleen het promptsjabloon van de huidige Action is op elk moment actief. De agent ziet geen sjablonen voor andere acties—hij ziet alleen zijn rolprefix plus de specifieke actiecontext. Dit is het smalste injectievenster van alle frameworks die we hebben onderzocht.

Contextparsefuncties binnen Action-klassen extraheren relevante informatie uit invoer, zodat elke actie een samengestelde subset van beschikbare context ontvangt in plaats van de volledige gespreksgeschiedenis.

Single-Turn Persistentie

Het sjabloon wordt bij elke actie-uitvoering opnieuw gerenderd. Er is geen ophoping of cross-sessie persistentie. Dit houdt elke actie gefocust maar betekent dat de agent niet kan voortbouwen op eerder geladen vaardigheidsinhoud binnen een enkele workflow.

Voyager: Embedding-Gebaseerd Ophalen van Vaardigheden voor Levenslang Leren

Voyager, de Minecraft-verkenningsagent van NVIDIA en Caltech, implementeert een van de meest elegante vaardigheidsinjectiearchitecturen: een groeiende bibliotheek van geverifieerde programma’s opgehaald op basis van embedding-gelijkenis.

De Vaardighedenbibliotheek

Wanneer Voyager code schrijft die zelfverificatie doorstaat (het gegenereerde Mineflayer JavaScript werkt daadwerkelijk in het spel), worden de code en de documentatiestring opgeslagen in een vectordatabase. De docstring-embedding wordt de ophaalsleutel.

Ophalen Per Taak

Bij elke nieuwe taak voorgesteld door het automatische curriculum:

1. De taakbeschrijving en omgevingsfeedback worden ingebed
2. Cosinus-gelijkeniszoekopdracht tegen alle opgeslagen vaardigheidsembeddings
3. Top-5 meest relevante vaardigheden worden opgehaald
4. Opgehaalde vaardigheidscode wordt opgenomen in de prompt van de actieagent als few-shot-voorbeelden

De prompt ziet er zo uit:

You are a Minecraft bot. Here are some relevant skills you've learned:

// Skill: mineWoodLog
async function mineWoodLog(bot) { ... }

// Skill: craftPlanks
async function craftPlanks(bot) { ... }

Now write code to: build a wooden pickaxe

De gegenereerde code kan opgehaalde vaardigheden bij naam aanroepen, wat compositionele vaardigheidsontwikkeling mogelijk maakt—complex gedrag opgebouwd uit eenvoudigere, geverifieerde primitieven.

Levenslange Persistentie

De vaardighedenbibliotheek is het kernmechanisme voor “levenslang leren”. Het groeit gedurende de gehele levensduur van de agent, en nieuwe vaardigheden bouwen voort op oude. In tegenstelling tot de meeste frameworks waar vaardigheden door mensen worden geschreven, worden Voyagers vaardigheden gegenereerd, geverifieerd en opgeslagen door de agent zelf.

Tokenkosten zijn van nature begrensd: ongeacht of de bibliotheek 50 of 5.000 vaardigheden bevat, betaalt elke taak alleen voor de 5 meest relevante ophalingen.

DSPy: Gecompileerde Few-Shot-Voorbeelden als Bevroren Vaardigheden

DSPy kiest een radicaal andere benadering dan elk ander framework. In plaats van vaardigheden tijdens runtime te injecteren, compileert DSPy optimale few-shot-demonstraties offline en bakt ze permanent in moduleprompts.

Het Compilatieproces

Twee hoofdoptimizers verzorgen de compilatie:

BootstrapFewShot: Gebruikt een leraarmodule om traces door het programma te genereren. Traces die een door de gebruiker gedefinieerde metriek halen, worden bewaard als demonstraties. Elke dspy.Predict-module binnen het programma krijgt zijn eigen samengestelde set demonstraties.

MIPROv2 (Multi-prompt Instruction Proposal Optimizer v2): Een driefasenproces:

1. Bootstrap: Genereer kandidaat-demonstratiesets
2. Voorstel: Genereer kandidaat-instructieteksten die zich bewust zijn van zowel de datadistributie als de demonstraties
3. Zoeken: Bayesiaanse optimalisatie over de gecombineerde ruimte van instructies x demonstraties over alle modules

Parameters zoals max_bootstrapped_demos (gegenereerde voorbeelden) en max_labeled_demos (uit trainingsdata) bepalen hoeveel voorbeelden in de prompt van elke module terechtkomen.

Vast Na Compilatie

Eenmaal gecompileerd worden demonstraties opgeslagen in het demos-attribuut van elke Predict-module en bij elke LLM-aanroep in de prompt geformatteerd. Ze veranderen niet tijdens runtime—de “vaardigheid” is bevroren.

Dit betekent dat DSPy-vaardigheden de meest voorspelbare zijn in onze vergelijking: tokenkosten zijn bekend na compilatie, er is geen variatie tussen beurten, en de agent ziet altijd dezelfde demonstraties. Het nadeel is inflexibiliteit—om vaardigheden te wijzigen moet je opnieuw compileren.

Persistentie

Gecompileerde programma’s serialiseren naar JSON, inclusief alle demonstraties. Ze zijn volledig persistent en laadbaar over sessies heen, wat DSPy een van de duurzaamste vaardigheidopslagmechanismen maakt.

SuperAGI: Toolkit-Gebaseerde Vooraf Registratie

SuperAGI gebruikt een traditioneel toolkit-patroon waarbij alle tools bij agentinitialisatie worden geregistreerd.

Elke toolkit breidt BaseToolkit uit met:

• name- en description-attributen
• get_tools()-methode die een lijst van BaseTool-instanties retourneert
• get_env_keys() voor vereiste omgevingsvariabelen

Toolkits worden geïnstalleerd vanuit GitHub-repositories via SuperAGI’s toolmanager. Bij agentinitialisatie retourneert BaseToolkit.get_tools() alle tools, en hun volledige schema’s worden aan het LLM gepresenteerd als functieaanroepdefinities.

Er is geen uitgesteld laden, geen progressieve onthulling en geen filtering per beurt. Het schema van elke geregistreerde tool is aanwezig in elke aanroep. Dit is het eenvoudigste injectiemodel en werkt goed voor agents met gefocuste, kleine toolsets maar schaalt niet naar agents die tientallen mogelijkheden nodig hebben.

CAMEL-AI: ChatAgent Tool-Registratie

CAMEL-AI volgt een vergelijkbaar patroon van vooraf registratie. Tools uit verschillende toolkits (bijv. MathToolkit, SearchToolkit) worden als lijst doorgegeven aan ChatAgent(tools=[...]) bij initialisatie.

Het framework benadrukt dat aangepaste functies duidelijke argumentnamen en uitgebreide docstrings nodig hebben zodat het model het gebruik kan begrijpen—het toolschema is de enige “vaardigheids”-inhoud die het model ziet. Er is geen apart instructie-injectiemechanisme.

Recente toevoegingen omvatten MCP-ondersteuning (Model Context Protocol) via MCPToolkit, waardoor ChatAgent verbinding kan maken met MCP-servers en externe tools kan registreren. Dit breidt het beschikbare tooloppervlak uit maar verandert het injectiemodel niet—alle ontdekte MCP-tools worden nog steeds vooraf geregistreerd.

Cross-Platform Vergelijking

Wanneer Vaardigheden Worden Geïnjecteerd

Persistentiemodellen

Overleving bij Contextcompactie

Het Progressieve Onthullingspatroon

De meest significante architecturale trend over deze platforms heen is de adoptie van progressieve onthulling—een concept ontleend aan UI-design waarbij informatie stapsgewijs wordt onthuld op basis van behoefte.

Waarom Progressieve Onthulling Belangrijk Is

Een naïeve benadering van vaardigheidsinjectie—alles vooraf laden—creëert twee problemen:

1. Tokenverspilling: De meeste vaardigheden zijn niet relevant voor de meeste beurten. 20 volledige vaardigheidsbodies laden wanneer er maar 1-2 per beurt nodig zijn, verspilt 90%+ van vaardigheidsgerelateerde tokens.
2. Aandachtverdunning: Onderzoek naar contextvervuiling toont aan dat LLM’s slechter presteren wanneer hun context grote hoeveelheden irrelevante informatie bevat. Meer vaardigheden in context kan de kwaliteit van vaardigheidstoepassing zelfs verminderen.

Progressieve onthulling lost beide problemen op door een lichtgewicht index van beschikbare vaardigheden te onderhouden terwijl volledige inhoud alleen wordt geladen wanneer nodig.

Implementatievariaties

Claude Code gebruikt een speciaal systeem: vaardigheidsmetadata in system-reminder-berichten, een Skill tool voor activering en ToolSearch voor uitgestelde toolschema’s. Het framework beheert injectie automatisch met prioriteitsgebaseerde compactie.

LangChain Deep Agents gebruikt de bestaande bestandsleescapaciteit van de agent: SkillsMiddleware injecteert de index, en de agent laadt volledige inhoud via read_file(). Dit is transparanter maar biedt minder framework-niveau optimalisatie.

OpenAI Responses API gebruikt namespace-gebaseerde groepering met platformbeheerde zoekopdrachten: toolnamespaces bieden beschrijvingen op hoog niveau, en tool_search retourneert relevante schema’s. Het platform verzorgt de zoeklogica volledig.

Tokenbesparingen in de Praktijk

De cijfers zijn overtuigend. Met 12 vaardigheden:

• Always-on injectie (CrewAI/SuperAGI-stijl): ~30.000 tokens
• Progressieve onthulling alleen index: ~600 tokens
• Index + 2 geactiveerde vaardigheden: ~2.000–5.000 tokens

Dat is een reductie van 83–98% in vaardigheidsgerelateerd tokenverbruik per beurt. Over een lange sessie met honderden beurten stapelen de besparingen zich dramatisch op.

Architecturale Patronen en Afwegingen

Over alle 11 platforms heen komen vier verschillende architecturale patronen naar voren:

Patroon 1: Always-On Injectie

Gebruikt door: CrewAI, SuperAGI, CAMEL-AI, Semantic Kernel

Hoe het werkt: Volledige vaardigheidsinhoud of toolschema’s zijn aanwezig in elke LLM-aanroep.

Voordelen:

• Maximale betrouwbaarheid—de agent heeft altijd volledige expertise beschikbaar
• Eenvoudigste implementatie—geen activeringslogica nodig
• Voorspelbare tokenkosten—elke beurt hetzelfde

Nadelen:

• Tokenkosten schalen lineair met het aantal vaardigheden
• Aandachtverdunning bij veel vaardigheden
• Schaalt niet voorbij ~5-10 vaardigheden per agent

Best voor: Gefocuste agents met 1-3 kernvaardigheden die altijd relevant zijn.

Patroon 2: Progressieve Onthulling

Gebruikt door: Claude Code, LangChain Deep Agents, OpenAI Responses API/Agents SDK

Hoe het werkt: Lichtgewicht metadata altijd aanwezig; volledige inhoud on-demand geladen.

Voordelen:

• Schaalt naar tientallen of honderden beschikbare vaardigheden
• Minimale tokenkosten wanneer vaardigheden niet nodig zijn
• Behoudt promptcache wanneer volledige schema’s aan het einde worden toegevoegd

Nadelen:

• Agent kan het signaal missen om een relevante vaardigheid te activeren
• Extra latentie door de activeringsstap
• Complexere framework-implementatie

Best voor: Algemene agents die toegang nodig hebben tot veel mogelijkheden maar er slechts een paar per taak gebruiken.

Patroon 3: Semantisch Ophalen

Gebruikt door: AutoGen Teachability, Voyager

Hoe het werkt: Vectordatabasequery’s brengen relevante vaardigheden/kennis naar boven op basis van semantische gelijkenis met de huidige context.

Voordelen:

• Van nature begrensde tokenkosten ongeacht bibliotheekgrootte
• Inhoudsrelevantie verbetert in de loop van de tijd naarmate de bibliotheek groeit
• Cross-sessie leren en accumulatie
• Geen expliciete activering nodig—relevantie wordt automatisch berekend

Nadelen:

• Ophaalkwaliteit hangt af van embeddingmodelkwaliteit
• Risico op het ophalen van verouderde of subtiel onjuiste informatie
• Vereist vectordatabase-infrastructuur
• Minder voorspelbaar—verschillende beurten laden verschillende inhoud

Best voor: Agents die leren van ervaring en in de loop van de tijd domeinkennis moeten opbouwen.

Patroon 4: Gecompileerde/Statische Injectie

Gebruikt door: DSPy, MetaGPT

Hoe het werkt: Vaardigheden worden gecompileerd tot vaste promptinhoud (DSPy) of geactiveerd via rigide actiesjablonen (MetaGPT).

Voordelen:

• Meest voorspelbare gedrag—elke keer dezelfde inhoud
• Optimalisatie kan offline worden gedaan (DSPy’s compilatie)
• Geen runtime-overhead voor vaardigheidsselectie
• Bewezen effectief voor goed gedefinieerde, herhaalbare taken

Nadelen:

• Inflexibel—vaardigheden wijzigen vereist hercompilatie (DSPy) of codewijzigingen (MetaGPT)
• Kan zich niet aanpassen aan nieuwe situaties buiten de gecompileerde voorbeelden
• DSPy’s compilatieproces zelf vereist veel LLM-aanroepen

Best voor: Productiepipelines met goed gedefinieerde taken waarbij betrouwbaarheid boven flexibiliteit gaat.

Praktische Implicaties voor Agentbouwers

Het Juiste Patroon Kiezen

De juiste vaardigheidsinjectiearchitectuur hangt af van het profiel van je agent:

Als je agent een smalle, goed gedefinieerde rol heeft (bijv. een codereviewbot, een klantenserviceagent voor één product), is always-on injectie (CrewAI/SuperAGI-patroon) het eenvoudigst en meest betrouwbaar. De tokenkosten van 2-3 altijd aanwezige vaardigheden zijn beheersbaar, en je vermijdt de complexiteit van activeringslogica.

Als je agent brede mogelijkheden nodig heeft maar er slechts een paar per interactie gebruikt (bijv. een ontwikkelaarassistent, een algemene automatiseringsagent), is progressieve onthulling (Claude Code/Deep Agents-patroon) de duidelijke winnaar. De 83-98% tokenbesparingen op schaal zijn te significant om te negeren.

Als je agent moet leren en verbeteren van interacties (bijv. een persoonlijke assistent, een domeinexpert die kennis accumuleert), biedt semantisch ophalen (AutoGen Teachability-patroon) de leerlus die andere patronen missen. Zorg er wel voor dat je kwaliteitscontroles hebt op wat in de kennisbank terechtkomt.

Als je agent goed gedefinieerde pipelines uitvoert (bijv. gegevensverwerking, rapportgeneratie, gestandaardiseerde workflows), geeft gecompileerde injectie (DSPy-patroon) je het meest voorspelbare, geoptimaliseerde gedrag.

De Hybride Aanpak

Voor productie-agentteams waar agents direct uit de doos moeten werken, raden we een hybride aanpak aan:

Kernvaardigheden (1-2 per agent, die hun primaire domeinexpertise definiëren): altijd geïnjecteerd in de systeemprompt, CrewAI-stijl. Dit zijn ononderhandelbare mogelijkheden die de agent bij elke beurt nodig heeft.

Uitgebreide vaardigheden (aanvullende mogelijkheden die de agent mogelijk nodig heeft): alleen metadata in de systeemprompt, geladen via een zoek-/laadmechanisme wanneer nodig, Deep Agents-stijl. Deze breiden de mogelijkheden van de agent uit zonder tokenkosten te betalen wanneer ze niet relevant zijn.

Aangeleerde kennis (geaccumuleerde domeinexpertise): opgeslagen in een vectordatabase en semantisch opgehaald per beurt, AutoGen-stijl. Dit stelt de agent in staat in de loop van de tijd te verbeteren zonder handmatige vaardigheidsschrijving.

Deze gelaagde architectuur sluit natuurlijk aan bij hoe een systeemprompt wordt opgebouwd: datum → persona → systeeminstructies → kernvaardigheden → vaardigheidsindex → rol-/teamcontext. De kernvaardigheden en index voegen voorspelbare, beheersbare tokenkosten toe, terwijl de volledige vaardigheidsbodies alleen verschijnen wanneer nodig.

Best Practices voor Tokenbudgetten Over Frameworks Heen

Ongeacht welk injectiepatroon je gebruikt, zijn deze tokenbeheersstrategieën universeel toepasbaar:

Cache-Vriendelijke Volgorde

Stapel onveranderlijke context (systeeminstructies, toolschema’s) aan het begin van de prompt. Bij providers die promptcaching ondersteunen, kosten gecachte tokens 75% minder. Claude Code en OpenAI injecteren beide ontdekte toolschema’s aan het einde van de context specifiek om cachehits op het statische prefix te behouden.

Offloading

Vat toolresponsen samen in plaats van volledige resultaten in context te bewaren. Sla de complete data op in externe referenties die de agent on-demand kan lezen. Dit is vooral belangrijk voor agents die veel toolaanroepen per sessie doen.

Reductie

Comprimeer gespreksgeschiedenis door samenvatting. Extraheer sleutelfeiten uit lange gesprekken naar gecondenseerde representaties. Elk framework met sessiegerbaseerde persistentie profiteert van agressief geschiedenisbeheer.

Ophalen Boven Vooraf Laden

Haal relevante informatie dynamisch op tijdens runtime in plaats van alles vooraf te laden. Dit geldt voor vaardigheden, kennisbanken en zelfs gespreksgeschiedenis. Onderzoek toont aan dat dit promptgroottes met tot 70% kan verminderen.

Isolatie

Gebruik subagents voor specifieke taken zodat de context van elke agent gefocust blijft. In plaats van één agent 20 vaardigheden te geven, maak een team van 5 agents met elk 4 vaardigheden. Elke agent behoudt een slank contextvenster, en het team dekt collectief de volledige mogelijkhedenset.

Conclusie

De manier waarop AI-agentframeworks vaardigheden in context injecteren is een van de meest invloedrijke architecturale beslissingen in agentontwerp—toch wordt het zelden op dit detailniveau besproken.

Het veld convergeert duidelijk naar progressieve onthulling als het voorkeurspatroon voor algemene agents, waarbij Claude Code, LangChain Deep Agents en OpenAI allemaal onafhankelijk tot vergelijkbare drielaagse architecturen zijn gekomen. Ondertussen dienen gespecialiseerde patronen zoals semantisch ophalen (AutoGen, Voyager) en gecompileerde injectie (DSPy) belangrijke niches die progressieve onthulling alleen niet adresseert.

Voor beoefenaars die vandaag agentsystemen bouwen, is het belangrijkste inzicht dat vaardigheidsinjectie geen one-size-fits-all probleem is. De juiste aanpak hangt af van de rol van je agent, het aantal vaardigheden dat het nodig heeft, of het in de loop van de tijd moet leren, en je tolerantie voor tokenkosten versus betrouwbaarheidsafwegingen.

De meest robuuste productiesystemen zullen waarschijnlijk meerdere patronen combineren—always-on voor kernmogelijkheden, progressieve onthulling voor uitgebreide vaardigheden en semantisch ophalen voor geaccumuleerde kennis—waardoor agents ontstaan die zowel efficiënt als deskundig zijn.