Wat zijn subagenten in Claude Code? Wat u moet weten

Onderagenten (vaak geschreven subagenten or subagenten) zijn een van de duidelijkste praktische ontwikkelingen in agentische ontwikkelaarstools: ze laten je een klein team van gespecialiseerde AI-assistenten samenstellen binnen Claude-code, elk met zijn eigen rol, tools en contextvenster. Het idee is simpel maar krachtig: in plaats van één generalistisch model alles te laten doen, definieert u compacte, doelgerichte agents waaraan de hoofdorchestrator werk delegeert (automatisch of wanneer u ze expliciet aanvraagt). Dit verandert de manier waarop u context, tools en de kosten-/latentie-afwegingen van complexe workflows beheert.

Wat zijn subagenten?

Korte definitie. Een subagent is een vooraf geconfigureerde, taakgerichte AI-"persoonlijkheid" waaraan Claude Code een taak kan delegeren. Elke subagent heeft een eigen systeemprompt, een eigen (geïsoleerd) contextvenster, expliciet toegewezen tools en optioneel een modelselectie. Subagenten kunnen op project- of gebruikersniveau worden aangemaakt en automatisch door Claude of expliciet door de gebruiker worden aangeroepen.

Belangrijkste eigenschappen van een subagent

Gespecialiseerd doel en systeemprompt. U beschrijft de rol, beperkingen en aanpak van de subagent in zijn systeemprompt, zodat deze zich voorspelbaar gedraagt voor zijn smalle domein (bijvoorbeeld code-reviewer, debugger, data scientist).
Geïsoleerd contextvenster. Elke subagent behoudt zijn eigen gespreksgeschiedenis en context, waardoor de context van de hoofdthread niet vervuild raakt met details van laag niveau. Dit is essentieel voor het schalen van workflows die anders de context van één gesprek uitputten.
Bereik en machtigingen van tools. U kunt bepalen of een subagent interne tools of externe Model Context Protocol (MCP)-tools mag gebruiken. Dit is een cruciale veiligheids- en governancefunctie.
Configureren als code. Subagenten worden gedefinieerd als Markdown-bestanden met YAML-frontmaterie (naam, beschrijving, hulpmiddelen, model) en worden opgeslagen op projectniveau (.claude/agents/) of gebruikersniveau (~/.claude/agents/). Projectdefinities hebben voorrang.

Wat zijn automatische delegatie en expliciete aanroep?

Claude Code kan webmaster. delegeer taken aan subagenten wanneer uw prompt of de subagent description komt overeen met de taak - of je kunt uitdrukkelijk een agent aanvragen (bijv. > Use the code-reviewer subagent to check my recent changes). Maak de description actiegericht ("Use PROACTIVELY", "MUST BE USED") om automatische delegatie te stimuleren, twee complementaire manieren om subagenten te gebruiken in Claude Code:

Automatische delegatie — Claude inspecteert het verzoek en delegeert proactief het bijbehorende werk aan een subagent.
Expliciete aanroeping — je roept een subagent aan bij naam in je prompt/opdracht (bijvoorbeeld, Use the code-reviewer subagent to check my changes).

Beide benaderingen hebben verschillende afwegingen op het gebied van UX en engineering. Hieronder leg ik ze uit.

Automatische delegatie

Hoe het er voor gebruikers uitziet. U geeft een opdracht op hoog niveau (bijvoorbeeld 'Bereid een beveiligingsaudit voor deze nieuwe bibliotheek voor') en Claude detecteert dat een of meer subagenten goed passen op basis van de description veld in hun configuraties. Indien geconfigureerd voor proactief gebruik, wordt de subagent automatisch verzonden en worden de resultaten geretourneerd als gestructureerde uitvoer.

Waarom teams het gebruiken.

Het verlaagt de cognitieve belasting: u hoeft niet elke subagentnaam te onthouden of te typen.
Het zorgt voor een soepelere onboarding bij gedeelde workflows, waarbij specifieke taken altijd door dezelfde specialist moeten worden uitgevoerd.

Let op:

Je moet de description en de systeemprompt opzettelijk, zodat Claude altijd de juiste subagent selecteert.
Te gretige delegering kan leiden tot meer tokengebruik en meer ruis als er veel subagenten voor dezelfde taken worden geactiveerd. Wees daarom voorzichtig bij het opstellen van uw beschrijvingen.

Expliciete aanroeping

Hoe het er voor gebruikers uitziet. Je roept expliciet een subagent aan: > Use the test-runner subagent to run the project testsDe orkestratie is deterministisch: Claude roept de genoemde subagent aan met zijn vooraf geconfigureerde rechten en prompt.

Waarom teams het gebruiken.

Volledige controle: u bepaalt precies welke specialist wordt uitgevoerd, wat het debuggen en de reproduceerbaarheid vereenvoudigt.
Gemakkelijker redeneren over kosten en toegang tot tools in CI of geautomatiseerde scripts.

Let op:

Meer typen en discipline: ontwikkelaars of automatiseringsmedewerkers moeten de juiste namen van subagenten kennen.
Minder opportunistisch: u verliest een deel van het gemak, aangezien de hoofdagent automatisch een goede subagent zou hebben gedetecteerd.

Hoe subagenten werken - het technische overzicht

Hieronder vindt u een praktisch, implementatiegericht overzicht van wat er gebeurt wanneer u een subagent maakt en gebruikt.

Een subagent definiëren (configuratie als code)

Een subagent is een Markdown-bestand met YAML-voorwoord. Belangrijke velden zijn onder andere:

name — een unieke kleine letter-id (met koppelteken)
description — beschrijving in natuurlijke taal die wordt gebruikt voor automatische delegatiematching
tools — optionele kommalijst met toegestane hulpmiddelen (of weggelaten om alle hulpmiddelen te erven)
model — optionele alias (sonnet, opus, haiku) Of inherit om het model van het hoofdgesprek te gebruiken

Een klein voorbeeld (conceptueel, niet letterlijk uit de documentatie):

---
name: code-reviewer
description: Expert code reviewer. Proactively reviews code for quality, security, and maintainability.
tools: Read, Grep, Bash
model: inherit
---
You are a senior code reviewer. Focus on security, correctness, and maintainability.

Deze bestanden bevinden zich in .claude/agents/ (project scope) of ~/.claude/agents/ (gebruikersbereik). Projectbestanden hebben voorrang, waardoor het delen en versiebeheer van subagenten eenvoudig is.

Modelselectie en hulpmiddelen

Modelveld: Je kunt een specifieke modelalias voor de subagent kiezen of deze het model van de hoofdconversatie laten overnemen. Zo kun je kosten-kwaliteitsafwegingen combineren (gebruik bijvoorbeeld een goedkoper model voor subagenten die grote hoeveelheden data scannen en een model van hogere kwaliteit voor de uiteindelijke synthese).
Reikwijdte van tools: Door elke subagent een minimale set tools te geven, wordt de explosieradius verkleind en wordt het redeneren over veiligheid vereenvoudigd. Tot de tools behoren de standaard Claude Code-primitieven (Read, Grep, Bash, Edit, enz.) en door MCP geleverde integraties.

Runtime-gedrag en contextverwerking

Wanneer Claude delegeert aan een subagent, ontvangt die subagent:

De systeemprompt (de inhoud van YAML/Markdown).
Alleen de context die het nodig heeft (zijn eigen contextvenster).
Toegang tot gereedschap zoals toegestaan in de configuratie.

Omdat elke subagent een geïsoleerde context behoudt, kunnen lange onderzoeken of grote bestandsanalyses worden opgedeeld in veel kleine contexten, in plaats van dat één enkele context alles moet bevatten. Dit is een groot voordeel voor zowel de betrouwbaarheid als de interpreteerbaarheid.

Architectuurpatronen voor subagent

De meest voorkomende architectuur is een orchestrator (hoofdagent) die een taak op hoog niveau opsplitst, meerdere subagenten opstart en vervolgens hun output synthetiseert of verifieert. Er zijn twee gangbare patronen in het wild:

1) Orkestrator + Specialisten

Eén agent (de orchestrator) coördineert meerdere subagenten parallel of serieel. De orchestrator bepaalt welke specialist hij aanroept, aggregeert de output, controleert de consistentie en voert de uiteindelijke integratie uit. Dit is de gebruikelijke aanpak waarbij de manager delegeert aan teamleden en komt overeen met veel voorbeelden en aanbevolen ontwerpen in Claude Code-materiaal. Voordelen zijn onder andere parallellisme, een duidelijkere scheiding van aandachtspunten en eenvoudigere foutbeheersing (een buggy subagent beïnvloedt alleen de scope).

Wanneer gebruik je het: complexe taken met onafhankelijke subproblemen (bijvoorbeeld ‘tests genereren’, ‘statische analyse uitvoeren’, ‘een module herschrijven’ en vervolgens ‘end-to-end tests integreren en uitvoeren’).

Zwakke punten: Orkestratielogica kan complex worden; extra round-trips kunnen de latentie licht verhogen.

2) Pijpleiding-/ketenspecialisten

Subagenten worden hier in een volgorde gerangschikt waarbij de output van de ene subagent de input wordt van de volgende (bijv. spec → scaffold → implement → test → optimize). Dit is in wezen functiecompositie uitgedrukt als agents – handig wanneer u stapsgewijze transformaties en strikte garanties nodig hebt over hoe gegevens tussen fasen stromen. Het is conceptueel eenvoudiger voor lineaire workflows en soms gemakkelijker te debuggen.

Wanneer gebruik je het: deterministische transformaties met meerdere stappen (bijvoorbeeld het vertalen van een ontwerpdocument naar een ondersteunde code, gevolgd door tests en optimalisaties).

Zwakke punten: minder geschikt voor taken die een brede verkenning vereisen (onderzoek, brainstormen) en één kapotte link kan de hele pijplijn doen vastlopen.

Waarin verschilt een subagent van een simpele rolgebaseerde prompt?

1) Aparte contextvensters

Elke subagent krijgt een eigen contextbuffer waarin uitwisselingen, bestanden en metadata worden opgeslagen die relevant zijn voor zijn rol. Dit voorkomt dat de context van de hoofdsessie wordt vervuild door ruisende tussenliggende berichten, en het betekent ook dat u de geschiedenis voor elke functionaliteit kunt behouden – of beperken. Zo kunt u met Claude Code langdurige contexten met een hoog signaal voor gespecialiseerde taken behouden zonder de tokenkosten of cognitieve overhead te betalen die gepaard gaan met het proppen van alles in één prompt.

2) Systeemprompts en persona's

Subagenten worden aangemaakt met instructies op systeemniveau die hun rol, toon en beperkingen definiëren (bijvoorbeeld "Functioneer alleen als refactoringspecialist; voer geen shell-opdrachten uit" of "Genereer unittests in Pytest-stijl; gebruik alleen openbare interfaces"). Deze prompts fungeren als taakomschrijvingen voor de subagent en worden tijdens runtime afgedwongen door de runtime van Claude Code.

3) Toolbindingen en toestemmingsbereik

Een cruciaal praktisch verschil: subagenten kunnen toegang krijgen tot specifieke tools – bestandssysteem, procesuitvoering, externe API's of geprivilegieerde datasets – of deze juist worden geweigerd. Dat maakt subagenten krachtig voor minste privilege Ontwerpen: een documentatiegenerator kan worden geblokkeerd voor het uitvoeren van willekeurige opdrachten, terwijl een CI-subagent een geïsoleerde sandbox krijgt. Veel communityberichten pleiten voor het koppelen van subagenten aan Model Context Protocol (MCP) of een hooks-gebaseerde MCP-server om veilige toegang tot geheimen en I/O te beheren.

4) Modelkeuze en afwegingen tussen kosten en prestaties

Omdat subagenten modulair zijn, kunt u verschillende onderliggende modellen toewijzen, afhankelijk van de complexiteit van de taak. Gebruik een Sonnet-model met hoge capaciteit voor diepgaande analyse of een lichtgewicht Haiku-model voor snelle, repetitieve taken. Deze heterogene implementatie helpt bij het balanceren van latentie, tokenkosten en capaciteit. De productupdates en communityartikelen van Anthropic benadrukken de parallelle implementatie van kleinere modellen voor kosteneffectieve schaalbaarheid.

5) Communicatiepatronen

Subagenten communiceren met de orchestrator (of met elkaar) via gestructureerde berichten of bestanden. Typische patronen zijn onder andere:

het retourneren van een gestructureerde JSON-payload (bij voorkeur voor programmatische orkestratie),
schrijven naar een bestand met een scope in een gedeelde werkruimte,
of door een definitief geformatteerd bericht terug te sturen naar de orchestrator, met daarin een betrouwbaarheidsscore en een onderbouwing.
Uit experimenten in de community blijkt dat teams de voorkeur geven aan expliciete, machinaal leesbare overdrachten om dubbelzinnigheid te voorkomen.

Prestatievoordelen

Subagenten zijn niet alleen een mooi ontwerp, ze leveren praktische prestaties en kwaliteitsvoordelen als ze correct worden gebruikt.

1) Verkorte wandkloktijd door parallelisme

Door meerdere workers gelijktijdig in te schakelen (bijvoorbeeld één worker per repositorymap, per microservice of per datablok), verkort de orchestrator de tijd die nodig is om grote samengestelde taken uit te voeren. Usecases zoals het sorteren van bugrapporten, het genereren van documentatie voor meerdere modules of het auditen van meerdere services zijn hiervoor een logische keuze. Dit leidt tot aanzienlijke versnellingen in de workflows van ontwikkelaars wanneer workloads daadwerkelijk parallelliseerbaar zijn.

Door elke rol een eigen context te geven, voorkom je directe opgeblazenheid en verminder je het risico op hallucinaties veroorzaakt door irrelevante historische ruis. Dat betekent minder contextgerelateerde fouten en consistentere resultaten voor gespecialiseerde taken. Community-artikelen en eigen onderzoek van Anthropic tonen aan dat multi-agent-opstellingen vaak beter presteren dan monolithische agents bij breedtegerichte taken. Een interne evaluatie van Anthropic rapporteerde aanzienlijke verbeteringen voor taken in onderzoeksstijl met een architectuur met een lead agent en subagenten.

Let op: parallellisme levert de beste resultaten op wanneer subtaken onafhankelijk zijn. Als werknemers constant op elkaar moeten wachten of een zware taakstatus moeten delen, zie je afnemende opbrengsten.

2) Betere contextbenutting en minder tokenverspilling

In plaats van elk tussenliggend zoekresultaat in één globale context te proppen, behouden workers alleen wat relevant is binnen hun eigen venster en retourneren ze gedistilleerde resultaten. Dit vermindert het tokenverbruik voor de orchestrator en verkleint het risico op het bereiken van contextlimieten – een praktisch voordeel wanneer u werkt met grote codebases, lange logs of grote documentrepositories. De compactie/samenvatting van de SDK breidt het effectieve geheugen van langlopende agents verder uit.

3) Verbeterde nauwkeurigheid dankzij specialistische aanwijzingen

Een subagent die is opgebouwd als een specialist met een beperkte reikwijdte, kan worden afgestemd (via de systeemprompt en toolset) om de precisie binnen zijn domein te optimaliseren: beveiligingscontroles, codestijl of compliance-extractie. Prompts met een beperkte reikwijdte verminderen hallucinaties vaak, omdat de toegestane actieruimte en verwachte output van de agent beperkt zijn. Organisaties rapporteren output van hogere kwaliteit voor taken zoals geautomatiseerde codereview wanneer ze domeinspecifieke subagenten gebruiken in plaats van een generalist alles te laten doen.

Hoe teams subagenten daadwerkelijk gebruiken - voorbeeldworkflows

Hieronder staan concrete voorbeelden om het minder abstract te maken.

Voorbeeld A — Refactoring-pijplijn (Orchestrator + Specialisten)

Orchestrator ontvangt een verzoek om “component X te refactoren”.
Orchestrator-oproepen analysis-subagent (geen schrijfrechten) om complexiteitshotspots en riskante afhankelijkheden te identificeren.
Orchestrator-oproepen refactor-subagent (schrijfpermissies naar een branch-achtige sandbox) om gerefactoriseerde bestanden te produceren.
Orchestrator-oproepen test-gen-subagent (alleen-lezen op code) om unittests te produceren.
Orchestrator voert CI uit met ci-runner-subagent (sandbox-uitvoering) en verzamelt de resultaten voor menselijke beoordeling.
Met dit patroon wordt elke fase geïsoleerd, worden risico's ingeperkt en blijven audit trails overzichtelijk.

Voorbeeld B — Onderzoek + prototype (pijplijn)

literature-subagent schrapt en vat referenties samen (geen bestandsschrijfbewerkingen, gereguleerde webtoegang).
prototype-subagent stelt een minimale PoC op uit de samenvatting.
benchmark-subagent voert microbenchmarks uit in een sandbox en rapporteert de resultaten.
Deze keten versterkt het opeenvolgende karakter van onderzoekstaken, terwijl de verantwoordelijkheden duidelijk blijven.

Beste praktijken en patronen

Ontwerp en configuratie

Begin met kleine, beperkte rollen. Maak elke subagent verantwoordelijk voor één specifieke taak. Beperkte verantwoordelijkheden maken het debuggen veel eenvoudiger.
Versiebeheer uw .claude/agents/ map. Behandel subagentdefinities als code: review, test en pin versies. Dit vermindert drift en vereenvoudigt audits.
Pin gereedschappen en modellen doelbewust vast. Gebruik model: inherit Als u consistent gedrag met het hoofdgesprek wilt, specificeert u een goedkopere modelalias voor achtergrondscans. Vergrendel tools om het aanvalsoppervlak te minimaliseren.

Operationele patronen

Gebruik expliciete aanroep voor deterministische automatisering. Als u CI-taken of -hooks uitvoert, roept u specifieke subagenten aan om voorspelbare resultaten te garanderen.
Gebruik automatische delegatie in interactieve sessies. Voor verkennend werk laat Claude subagenten kiezen om de wrijving te verminderen, maar maak description Velden worden opzettelijk zo ingesteld dat automatisering niet onverwachts wordt geactiveerd.
Ontwerp gestructureerde uitvoer voor synthese. Dwing subagenten om naar bestanden te schrijven of JSON te produceren die de orchestrator kan lezen. Dat vereenvoudigt de reductiestap en de auditing.

Testen, monitoren en governance

Maak representatieve evaluaties. Houd bij waar subagenten falen en ontwikkel tests die deze faalmodi onderzoeken. Anthropic adviseert representatieve testsets en iteratieve verbetering.
Houd toezicht op het gebruik van tokens en tools. Meet het gebruik van elke subagent en voeg waarschuwingen toe om te detecteren of de kosten te hoog oplopen of de snelheidslimieten worden overschreden.

Wanneer u GEEN subagenten moet gebruiken

Subagenten zijn krachtig, maar niet altijd het juiste hulpmiddel.

Eenvoudige taken: Bij korte, eenmalige prompts of triviale transformaties voegen subagenten onnodige complexiteit toe.
Strikte latentiebeperkingen: Orkestratie-roundtrips brengen extra overhead met zich mee. Als u reacties in één omwenteling en met extreem lage latentie nodig hebt, is een monolithische aanpak wellicht eenvoudiger.
Kleine teams met weinig infrastructuur: Zonder tools voor geheimen, observatie en sandboxen kunnen subagenten het operationele risico verhogen. Communityartikelen benadrukken dat je klein kunt beginnen en subagenten kunt toevoegen wanneer je modulariteit nodig hebt.

Waar Claude code cli het meest wordt aanbevolen

We zijn verheugd te kunnen melden dat CometAPI nu de krachtige Claude Code CLI volledig ondersteunt. U hoeft alleen Claude Code te installeren en u te verifiëren met de verkregen Comet API-sleutel en het basisadres om het Comet API-model op Claude Code te gebruiken.

Waarom moet ik claude-code gebruiken via CometAPI?

Belangrijkste functies van Kunstmatige Intelligentie: genereer, debug en optimaliseer eenvoudig code met behulp van modellen die speciaal voor ontwikkelaars zijn ontwikkeld.

Flexibele modelselectie: dankzij ons uitgebreide aanbod aan modellen kunt u soepeler ontwikkelen.
Naadloze integratie: API's zijn altijd beschikbaar. Integreer Claude Code binnen enkele minuten direct in uw bestaande workflow.
Door Claude Code via CometAPI te gebruiken, bespaart u meer kostenDe Claude API van CometAPI is 20% goedkoper dan de officiële prijs en wordt door de officiële leverancier bijgewerkt met het nieuwste model.

Klaar om Claude Code cli te gebruiken? raadpleeg de API-gids voor gedetailleerde instructies.

Als u meer tips, handleidingen en nieuws over AI wilt weten, volg ons dan op VK, X en Discord!

Zie ook Hoe installeer en voer ik Claude Code uit via CometAPI?

Conclusie — waarom subagenten nu belangrijk zijn

Subagenten maken de belofte van agentische workflows praktisch voor teams: ze laten je expliciet en als eersteklas objecten redeneren over rollen, rechten, context, kosten en parallellisatie. Bij verstandig gebruik zorgen subagenten voor een hogere ontwikkelsnelheid, betere kwaliteit bij taken met meerdere stappen en een beter voorspelbaar beheer. De keerzijde is dat je deze subagenten net als productiesoftware moet ontwerpen, testen en monitoren – maar die investering verandert snelle engineering in betrouwbare engineeringpraktijk.