Underagenter er et av de mest nyttige tilleggene til Claude Code / Claude Agent-økosystemet: de lar deg dele opp komplekse arbeidsflyter i mindre, spesialiserte AI-"lagkamerater", bevare hovedtrådkontekst og begrense verktøytilgang på en sikker måte. Denne artikkelen forklarer hva er underagenter, hvordan man oppretter og påkaller dem (CLI, filsystem og SDK), designprinsipper du bør følge når du bygger dem, og betong eksempelkode du kan kopiere og tilpasse.
Hva er underagenter?
A underagent er en forhåndskonfigurert, snevert begrenset AI-assistent som Claude Code (eller Claude Agent SDK) kan delegere arbeid til. Hver underagent:
- Har et unikt navn og en tydelig beskrivelse av formålet.
- Kjører i sin eget kontekstvindu atskilt fra hovedsamtalen (slik at lange detaljkjeder ikke forurenser orkestratorens kontekst).
- Kan konfigureres med et begrenset sett med verktøy (lesing/skriving av filer, bash, grep, MCP-verktøy osv.), og med et spesifikt modellvalg.
- Inneholder en systemledetekst (underagentens personlighet og instruksjoner) som veileder atferd og begrensninger.
Disse egenskapene gjør underagenter ideelle for oppgaver som er token-tunge (forskning, søking i store logger), sikkerhetssensitive (skanning eller potensielt destruktive verktøy), eller repeterende og godt spesifiserte (stilkontroll, testkjøring).
Anthropic har iterert raskt: Claude Code CLI og Agent SDK har blitt refaktorert og utvidet til Claude Agent SDK, plugin-støtte er introdusert for buntingsagenter og relaterte tilpasninger (slash-kommandoer, MCP-servere, hooks), og Ferdigheter gi en måte å pakke domenearbeidsflyter for gjenbruk på tvers av Claude.ai, Claude Code og Agent SDK. Disse oppdateringene gjør det enklere å del, installer og versjon underagenter på tvers av team og prosjekter. Hvis du planlegger å bygge produksjonsarbeidsflyter, bør du evaluere plugin-/ferdighetspakker og SDK-baserte distribusjonsmønstre.
Hvorfor underagenter er viktige
Tre grunner til at de er umiddelbart nyttige:
- Kontekstbevaring — lange eller støyende søk, testkjøringer eller skanninger ligger inne i en underagent i stedet for å overbelaste den primære konteksten. Det reduserer tokenavfall og gjør det lettere å resonnere rundt resultatene.
- Spesialkompetanse — du kan kode domenekunnskap og -atferd i en systemledetekst som er skreddersydd til oppgaven (f.eks. en
security-auditorsom fokuserer på hemmeligheter, avhengighetsproblemer og usikker skallbruk). - Sikrere tillatelser — å begrense verktøy per subagent reduserer eksplosjonsradiusen (en dokumentanmelder kan ha skrivebeskyttede verktøy; en testløper har
Bashmen neiEdit). - Parallellisering: Du kan sette opp flere underagenter som kjører samtidig (for eksempel:
style-checker,security-scanner,test-runner) og deretter samle inn de korte resultatene deres – en stor gevinst for dyre, uavhengige kontroller.
Forutsetninger for bruk av underagenter i Claude Code
Før du begynner å bygge underagenter, sørg for at du har følgende på plass:
1) Claude Code installert og autentisert
Installer Claude Code CLI eller bruk web/IDE-integrasjonene. CometAPIs hurtigstart- og oppsettdokumentasjon liste opp støttede installasjonsmetoder (npm global pakke eller native installatører) og vis hvordan du verifiserer installasjonen din med claude --version / claude doctorDu trenger også en CometAPI konto (Det er billigere og mer praktisk å bruke CometAPIs nøkkel for å få tilgang til Claude-koden enn den offisielle modellen.) som nevnt i hurtigstarten.
2) Node/miljø (for noen installasjonsstier) og grunnleggende skallverktøy
Hvis du installerer via npm-pakken, bør du ha Node.js (Node 18+ er vanlig i eksempler). Hvis du har tenkt å bruke Agent SDK (JavaScript/TypeScript eller Python), trenger du et prosjekt med SDK-avhengigheten installert. Mange veiledninger forutsetter standard utviklerverktøy (git, bash, valgfritt gh CLI for GitHub-arbeidsflyter).
3) Prosjektoppsett og CLAUDE.md
Beste praksis er å beholde hjelpedokumenter på reponivå (CLAUDE.md) og å sette inn prosjektomfattede agenter .claude/agents/ slik at lagkamerater arver dem. CLAUDE.md-filer trekkes automatisk inn i Claudes kontekst og bidrar til å veilede atferd konsekvent på tvers av økter. Hver underagent er en Markdown-fil med YAML-frontmatter. Minimalt eksempel:
---
name: code-reviewer
description: Expert code review specialist. Use PROACTIVELY after code changes to check security, style, and maintainability.
tools: Read, Grep, Glob, Bash
model: inherit
---
You are a senior code reviewer. When invoked:
1. Run `git diff` to identify modified files.
2. Focus review on changed code paths.
3. List security issues, probable false positives, and suggested fixes.
4. Provide a short, prioritized action list.
Return results in JSON with fields: summary, issues.
nameer en identifikator med små bokstaver.descriptionveileder automatisk påkalling og matching.toolsbegrenser verktøytilgang (utelater å arve alt).modelkan væresonnet,opus,haikuellerinherit.
4) Tillatelser og MCP-servere (valgfritt, men vanlig)
Hvis arbeidsflytene dine bruker Model Context Protocol (MCP)-servere eller eksterne verktøy (Puppeteer, Sentry, tilpassede REST-verktøy), må du sørge for at MCP-serverne dine er konfigurert og tilgjengelige. For sensitive operasjoner (skriving, bash, git commit) vær bevisst på tillatelseslisten og per-agent. tools omfang.
Slik oppretter du underagenter i Claude Code
Du kan opprette underagenter på tre hovedmåter: via det interaktive CLI-et (/agents), som markdown-filer for filsystemet, eller programmatisk gjennom Agent SDK. Nedenfor finner du trinnvise alternativer:
Claude Code støtter tre praktiske måter å opprette underagenter på:
- Interaktiv CLI
/agentsUI — raskest for iterativ oppretting i en økt. - Filsystembasert — opprett Markdown-filer med YAML frontmatter i
.claude/agents/(prosjektnivå) eller~/.claude/agents/(brukernivå). Prosjektagenter har høyere prioritet. - Programmatisk (Agent SDK) — definere underagenter i kode via
agentsparameter når du kallerquery(); anbefalt for SDK-drevne apper. Denne tilnærmingen er ideell når underagenter må opprettes dynamisk eller bygges inn i et program.
Rask interaktiv flyt (anbefalt første trinn)
- Start Claude Code i terminalen din, eller åpne kommandopaletten i VS Code.
- Kjør subagents-grensesnittet med slash-kommandoen:
/agents
- Velg Opprett ny agent, velg omfang på prosjektnivå eller brukernivå, fyll ut navn/beskrivelse/verktøy/systemledetekst og lagre. Du kan generere et utkast med Claude og deretter forbedre det. Når agenten er lagret, er den tilgjengelig i
/agentsog kan påberopes eksplisitt eller automatisk.
Filsystembaserte underagenter (Markdown + YAML frontmatter)
Subagenter lagres som Markdown-filer med YAML-frontmatter. Plasser dem i:
- Prosjektomfang:
.claude/agents/*.md(høyeste prioritet) - Brukeromfang:
~/.claude/agents/*.md
Grunnleggende filstruktur:
---
name: code-reviewer
description: "Review recent code changes for security and style."
tools: Read, Grep, Glob, Bash # optional; omit to inherit
model: sonnet # optional; or 'inherit'
---
You are a senior code reviewer with expertise in security, performance, and best practices.
When reviewing:
- Identify security vulnerabilities
- Prioritize clarity and maintainability
- Always provide concise examples and suggested fixes
- If unsure, ask for the minimal reproducible snippet
Noen implementeringsnotater:
namemå være små bokstaver med bindestreker.- Utelater
toolsvil la underagenten arve alle verktøyene i hovedtråden; eksplisitt opplisting av verktøy håndhever en modell med minst privilegier. - Bruk
model: 'inherit'for konsistent oppførsel med hovedtråden, eller spesifiser et modellalias (f.eks.sonnet,opus,haiku).
CLI JSON-definisjon (ad hoc/øktbruk)
Du kan definere midlertidige underagenter innebygd når du starter en økt:
claude --agents '{
"code-reviewer": {
"description": "Expert code reviewer.",
"prompt": "You are a senior code reviewer. Focus on security and best practices.",
"tools": ,
"model": "sonnet"
}
}'
CLI-definerte agenter er nyttige for skriptkjøringer eller eksperimenter; de har lavere prioritet enn prosjektagenter, men høyere enn brukeragenter.
Programmatisk definisjon (Agent SDK – anbefalt for apper)
Hvis du bygger en applikasjon eller automatisering, definer underagenter programmatisk via Agent SDK-ene. agents parameter (dette er det mest integrerte alternativet). Eksempel (TypeScript):
import { query } from '@anthropic-ai/claude-agent-sdk';
async function runReview() {
const result = await query({
prompt: "Assess the authentication module for security issues",
options: {
agents: {
"code-reviewer": {
description: "Expert code review specialist",
prompt: `You are a code review specialist...`,
tools: ,
model: "sonnet"
},
"test-runner": {
description: "Runs the test suite and analyzes failures",
prompt: `You run tests and summarize failures...`,
tools: ,
model: "sonnet"
}
}
}
});
console.log(result);
}
SDK-en godtar også filsystembaserte agenter (den vil laste .claude/agents/ filer) hvis du foretrekker det mønsteret. Programmatiske agenter er kraftige for dynamiske arbeidsflyter og CI-integrasjon.
For Python, claude-agent-sdk Pakken støtter lignende mønstre: du kan bruke query() or ClaudeSDKClient og konfigurer alternativer, verktøy og MCP-servere programmatisk. Se Python SDK-repoet for eksempler på hurtigstart.
Slik påkaller du underagenter
Automatisk delegering
Claude Code kan automatisk Velg en underagent når en brukerledetekst samsvarer med en underagents formål. Dette er nyttig for bakgrunnsorkestrering der hovedagenten automatisk ruter oppgaver til riktig spesialist. Stol på tydelige beskrivelser av underagenter og fokuserte systemledetekster for å forbedre nøyaktigheten av automatisk valg.
Eksplisitt påkallelse (anbefales for klarhetens skyld)
Du kan eksplisitt påkalle en agent i en samtale:
> Use the code-reviewer subagent to check my recent changes
Eksplisitt kall er deterministisk og anbefales for produksjonsflyter der du vil unngå uventet delegering.
SDK-orkestratormønstre
Vanlige mønstre i SDK-apper:
- Gaffel + samleStart flere underagenter parallelt, samle inn hver agents konsise svar, og oppsummer/slå sammen resultatene i hovedagenten.
- VeilederløkkeOrkestratoren tildeler oppgaver til underagenter, inspiserer resultatene og enten godtar dem eller ber om omberegning/avklaring.
- Sandkassebasert utførelseGi potensielt farlige funksjoner (distribuere, kjøre skript) til en strengt begrenset agent og krev eksplisitte menneskelige godkjenningskroker før utførelse.
Disse mønstrene tilordnes praktiske implementeringer ved hjelp av Agent SDKs økthåndtering, kroker og MCP-verktøy.
Hvordan lage subagenter som er nyttige, trygge og komponerbare
1) Enkelt ansvar og tydelige instruksjoner
Hver underagent bør ha ett klart formål og en systemledetekst som spesifiserer grenser, suksesskriterier og utdataformat. Hvis ønsket utdata er strukturert (JSON, punktliste, kodeoppdatering), instruer underagenten presist for å redusere parsefeil.
2) Minst mulig privilegium for verktøy
Gi kun verktøyene en underagent trenger. For eksempel trenger ikke en dokumentanmelder Write or BashBruk skrivebeskyttet standardinnstilling der det er mulig, og eskaler verktøytillatelser eksplisitt når det er nødvendig. Dette reduserer risiko og forenkler revisjon.
3) Returner kompakte, strukturerte resultater
Underagenter bør returnere konsise, endelige svar snarere enn langvarige tankespor. Et vanlig mønster er: gjør tungt arbeid innenfor underagentens kontekst, og returner deretter et kort sammendrag med vedlegg (patcher, filreferanser, JSON). Dette maksimerer konteksteffektiviteten for orkestratoren.
4) Testbarhet og versjonering
Lagre subagentfiler i versjonskontroll, opprett CI-tester som utfører reelle kjøringer mot små input, og fest modeller/verktøysett. Hvis du er avhengig av ferdigheter og plugins, ta i bruk plugin-markedsplassen/versjonsmønstrene for å administrere oppgraderinger og tilbakestillinger.
5) Revisjonskroker og kontrollpunkter med menneskelig innhold
Bruk SDK-kroker til å avskjære verktøyanrop (PreToolUse-kroker) og kreve menneskelig godkjenning for destruktive handlinger. Logg alle verktøyanrop for revisjoner som kan spilles av igjen. SDK-en tilbyr maskineri for krok- og tillatelsesfunksjoner for å støtte dette mønsteret.
Applikasjonseksempel – en liten, produksjonslignende pipeline
Nedenfor er et kompakt eksempel som viser de typiske delene: en filsystemagent, en SDK-påkallelse som bruker to agenter (én for gjennomgang, én for tester) og en enkel orkestrering.
1) Filsystemagent: .claude/agents/code-reviewer.md
---
name: code-reviewer
description: Use PROACTIVELY after code changes. Perform security, style, and maintainability review on modified files.
tools: Read, Grep, Glob
model: inherit
---
You are a meticulous senior code reviewer. When invoked:
1. Run `git diff --name-only` to find modified files.
2. For each modified file, read and look for security issues, suspicious patterns, or maintainability problems.
3. Return JSON:
{
"summary": "one-line summary",
"issues": ,
"recommended_changes":
}
2) Programmatisk orkestrering (Node.js)
import { query } from '@anthropic-ai/claude-agent-sdk';
import fs from 'fs';
async function runPipeline() {
const result = query({
prompt: 'Run PR checks: security review then unit tests.',
options: {
agents: {
'code-reviewer': {
description: 'Use PROACTIVELY after code changes; output JSON with issues.',
prompt: fs.readFileSync('./.claude/agents/code-reviewer.md', 'utf8'),
tools: ,
model: 'sonnet'
},
'test-runner': {
description: 'Run test suite and summarize failing tests.',
prompt: `You are a test-runner. Execute tests and return JSON { summary, failing_tests[] }`,
tools:
}
}
}
});
for await (const message of result) {
// Implement streaming logic: messages may include subagent outputs
console.log(message);
}
}
runPipeline().catch(console.error);
Merknader: de code-reviewer lagres i depotet for gjenbruk av teamet; SDK-kallet viser at programmatiske agenter har prioritet, og tools omfang forhindrer utilsiktede skrivinger.
Avanserte emner og mønstre
Dynamisk agentkonfigurasjon
Opprett parameteriserte agentfabrikker som velger modell og verktøysett avhengig av miljø (utvikling vs. produksjon) eller alvorlighetsnivåer (f.eks. strict vs balanced SDK-eksemplene viser hvordan du genererer agentdefinisjoner under kjøretid.
Parallellisering
Spinn ut flere skrivebeskyttede analyseagenter parallelt (stil, sikkerhet, testdekning) og aggreger JSON-utdataene deres i hovedtråden. Dette reduserer veggklokketiden for store repositorier betraktelig.
Plugin-leverte agenter
Programtillegg kan tilby underagenter pakket med programtilleggsmanifestet; de vises i /agents ved siden av tilpassede agenter og kan kalles eksplisitt. Bruk dette til å distribuere standardiserte agenter på tvers av team.
Hvor man skal bruke Claude-koden cli anbefales mest
Det var gledelig å kunngjøre at CometAPI nå støtter det kraftige Claude Code-klientet fullt ut. Du trenger bare å installere Claude Code og autentisere med den innhentede Comet API-nøkkelen og basisadressen for å bruke Comet API-modellen på Claude Code.
Hvorfor bruke Claude-kode gjennom CometAPI?
Toppfunksjoner innen kunstig intelligens: Generer, feilsøk og optimaliser kode enkelt ved hjelp av modeller som er spesielt utviklet for utviklere.
- Fleksibelt modellvalg: Vårt omfattende utvalg av modeller lar deg utvikle mer sømløst.
- Sømløs integrasjon: API-er er alltid tilgjengelige. Integrer Claude Code direkte i din eksisterende arbeidsflyt på få minutter.
- Å bruke Claude Code via CometAPI vil spare mer kostnaderClaude API-et som leveres av CometAPI har 20 % rabatt fra den offisielle prisen og er oppdatert med den nyeste modellen av den offisielle.
Klar til å bruke Claude Code cli? Se på API-veiledning for detaljerte instruksjoner.
Hvis du vil vite flere tips, guider og nyheter om AI, følg oss på VK, X og Discord!
Se også Hvordan installere og kjøre Claude-kode via CometAPI?
Avsluttende tanker
Behandle underagenter som gjenbrukbare, versjonerte mikropersonaerStart i det små: lag en doc-reviewer og en test-runner for et repo, sjekk dem inn .claude/agents/, og automatiser dem i CI ved hjelp av headless claude -pGjenta ledetekstene dine, legg til strukturerte utdata og stram verktøytillatelsene.
Den mentale modellen som hjelper mest: se for deg Claude som prosjektleder og underagenter som spesialister i teamet. Lederen delegerer tydelig formulerte oppgaver, samler spesialistenes leveranser og skriver den endelige rapporten. Over tid vil du se forbedringer i pålitelighet, testbarhet og muligheten til å automatisere store deler av utviklernes arbeidsflyter.