Opret brugerdefinerede GitHub Copilot-agenter i Visual Studio Code

Custom agents er specialiserede AI-assistenter, som du konfigurerer til bestemte roller eller arbejdsgange i Visual Studio Code. Hver agent indkapsler et sæt instruktioner og værktøjstilladelser, der styrer GitHub Copilots adfærd til at fungere som en specifik type ekspert. Når du vælger en brugerdefineret agent i GitHub Copilot Chat, overtager AI'en agentens persona, følger dens retningslinjer og bruger kun de værktøjer, du har tildelt den.

Hvad er brugerdefinerede GitHub Copilot-agenter?

En custom agent er en skræddersyet konfiguration, der forvandler GitHub Copilot Chat til en rollespecifik assistent. I stedet for at stole på generel adfærd arbejder en brugerdefineret agent efter instruktioner og begrænsninger, som du definerer. For eksempel kan du oprette en "Security Reviewer"-agent, der analyserer kode for sårbarheder, en "Test Writer"-agent, der fokuserer på at generere enhedstests, eller en "Planner"-agent, der laver implementeringsplaner uden at ændre nogen filer.

Brugerdefinerede agenter blev introduceret som en avanceret funktion i Visual Studio Code (tilgængelig fra Visual Studio Code version 1.106, tidligere kendt som "custom chat-tilstande"). De giver udviklere fintgående kontrol over, hvordan AI'en fungerer i forskellige udviklingskontekster. Hver agent vises i GitHub Copilot Chat-agenternes dropdown, hvor du kan vælge at skifte AI's tilstand når som helst.

Brugerdefinerede agenter kan gemmes to steder:

• Workspace-agenter: Gemt i .github/agents/ mappen i dit repository. Disse agenter deles med dit team gennem versionskontrol, så alle på projektet har adgang til de samme specialiserede assistenter.

• User profile agents: Gemt i prompt-mappen på din Visual Studio Code-brugerprofil. Disse agenter er personlige og tilgængelige på alle dine arbejdspladser, nyttige for agenter, der afspejler dine individuelle arbejdsgangspræferencer.

Undersøg, hvordan specialmæglere arbejder

En custom agent er en Markdown-fil med en .agent.md endelse. Visual Studio Code registrerer automatisk alle .agent.md filer i din arbejdsområdes .github/agents/ mappe (eller i din brugerprofil) og indlæser dem som tilgængelige agenter i GitHub Copilot Chat-grænsefladen.

Hver agentfil består af to dele:

• En YAML frontmatter-header: Denne sektion specificerer metadata, herunder agentens navn, en beskrivelse der vises i chatgrænsefladen, de værktøjer, den kan bruge, en valgfri modelpræference og handoff-konfigurationer for forbindelse til andre agenter.

• En Markdown-krop: Denne sektion indeholder agentens instruktioner og kontekst. Indholdet tilføjes til hver brugerprompt, når agenten er aktiv, hvilket guider, hvordan GitHub Copilot fortolker og besvarer forespørgsler. Du skriver disse instruktioner i samme naturlige sprogstil, som bruges til brugerdefinerede instruktionsfiler.

Agentfrontmateriefelter

YAML-frontmatteren understøtter følgende felter til konfiguration af agentadfærd:

Følgende eksempel viser strukturen af en brugerdefineret agentfil ved brug af flere af disse felter:

---
description: Reviews code for security vulnerabilities and suggests improvements
tools: ['search', 'read']
---
# Security Reviewer

You are a senior security engineer. When the user provides code or asks you to review files, analyze the code for common security vulnerabilities including:

- SQL injection
- Cross-site scripting (XSS)
- Authentication and authorization flaws
- Insecure data handling
- Hardcoded credentials or secrets

Provide your findings as a structured list with severity levels (Critical, High, Medium, Low). For each finding, explain the vulnerability, show the affected code, and suggest a secure alternative.

Do not modify any files. Your role is advisory only.

Når en udvikler vælger denne agent i GitHub Copilot Chat, bruger alle interaktioner disse instruktioner. Agenten "ved", at den skal fokusere på sikkerhedsanalyse og vil ikke forsøge at redigere filer, fordi dens instruktioner og værktøjssæt begrænser den til skrivebeskyttede operationer.

Definér agentens kapaciteter med værktøjer

Feltet tools i YAML-frontmaterialet styrer, hvilke handlinger agenten kan udføre. Værktøjer afgør, om agenten kan læse filer, redigere kode, søge i kodebasen, køre terminalkommandoer eller få adgang til andre funktioner. Ved at tilpasse værktøjslisten sikrer du, at hver agent kun udfører handlinger, der er relevante for dens rolle.

Almindelige værktøjer inkluderer:

Hvis du helt udelader feltet tools , får agenten som standard adgang til alle standardværktøjer. Dog er det bedste praksis at liste værktøjer eksplicit, fordi det skaber klare grænser for agentens adfærd. En planlægningsagent, der ikke bør ændre kode, bør kun ['search', 'read', 'fetch']specificere , mens en implementeringsagent, der skal skrive kode, vil inkludere ['search', 'read', 'edit', 'terminal'].

Subagenter

Feltet agents i YAML-frontmaterien lader en agent påkalde andre agenter som underagenter. En underagent er en agent, som en anden agent kalder for at håndtere en delopgave, og derefter inkorporerer resultatet i sit eget svar. Denne adfærd adskiller sig fra en handoff, som overfører kontrollen til brugeren; Et subagentkald sker inden for agentens behandling og returnerer resultatet automatisk til den kaldende agent.

For eksempel kunne en "Lead Developer"-agent påkalde en "Security Reviewer"-underagent for at tjekke et kodeuddrag, modtage resultaterne og derefter indarbejde disse fund i sit endelige svar – alt sammen i en enkelt interaktion.

For at konfigurere underagenter, list underagentnavnene i feltet agents :

---
description: Lead developer agent that coordinates with specialists
tools: ['search', 'read', 'edit']
agents: ['security-reviewer', 'test-writer']
---

Agenter, der kun er beregnet til brug som underagenter, kan sætte sig ind, user-invokable: false så de ikke vises i agentens dropdown, hvilket holder grænsefladen ren.

Agenter på organisationsniveau

For teams, der vedligeholder delte agenter på tværs af flere repositories, understøtter GitHub agenter på organisationsniveau. Disse agenter konfigureres på GitHub-organisationsniveau og vises automatisk sammen med workspace- og brugerprofilagenter i Visual Studio Code, når du er logget ind på en GitHub-konto med adgang til organisationen.

Agenter på organisationsniveau sikrer konsistens på tværs af teams. For eksempel kan et sikkerhedsteam offentliggøre en delt "Security Reviewer"-agent, som alle repositorys i organisationen kan bruge, hvilket sikrer, at de samme sikkerhedsreviewkriterier anvendes overalt uden at hvert repository behøver at definere sin egen agent.

Agentformat-kompatibilitet

Visual Studio Code genkender agentfiler i formatet .agent.md som den primære konfiguration. Derudover understøtter Visual Studio Code Claude-lignende agentfiler, der følger Claude Code-agentformatet. Hvis du allerede har agentkonfigurationer fra Claude Code, fungerer de i Visual Studio Codes GitHub Copilot Chat uden ændringer. Denne krydskompatibilitet forenkler migreringen for teams, der bruger flere AI-værktøjer.

Indbyggede vs. brugerdefinerede agenter

Visual Studio Code indeholder flere indbyggede agenter, der tilbyder generelle konfigurationer til chat. Disse agenter inkluderer standardagenten "GitHub Copilot" og specialiserede agenter til almindelige opgaver. Brugerdefinerede agenter udvider dette system ved at lade dig definere dine egne roller med projektspecifikke instruktioner og værktøjskonfigurationer.

Brugerdefinerede agenter vises i GitHub Copilot Chat-agenternes dropdown sammen med de indbyggede agenter. Du kan skifte mellem enhver agent når som helst for at ændre, hvordan AI'en fungerer. Denne fleksibilitet gør det muligt at bevæge dig mellem forskellige arbejdsformer – planlægning, kodning, gennemgang, test – uden at forlade GitHub Copilot Chat-grænsefladen.

Den største fordel ved brugerdefinerede agenter frem for indbyggede agenter er specificitet. En indbygget kodegennemgangsagent anvender generelle bedste praksisser, mens din tilpassede "Kodegennemgangsmægler" kan anvende dit teams specifikke gennemgangstjekliste, referere til projektets arkitektoniske beslutninger og fokusere på de mønstre og anti-mønstre, der betyder mest i din kodebase.

Trin til at oprette en brugerdefineret agent

Følg disse trin for at oprette en brugerdefineret agent i Visual Studio Code:

1. Åbn agentmenuen: I GitHub Copilot Chat-panelet åbner du agentens dropdown (som normalt viser det aktuelle agentnavn). Vælg Konfigurér brugerdefinerede agenter og vælg derefter Opret ny brugerdefineret agent. Alternativt kan du køre kommandoen Chat: New Custom Agent fra Command Palette (Ctrl+Shift+P).

2. Vælg scope: Vælg hvor agentfilen skal opbevares. Vælg Workspace til at oprette filen i .github/agents/ (så den er tilgængelig for dit team via versionskontrol), eller vælg Brugerprofil for at gøre den personlig og tilgængelig på alle dine workspaces.

3. Navngiv agenten: Indtast et beskrivende filnavn for agenten. Dette navn vises som standardnavn i agentens dropdown. Brug et navn, der tydeligt angiver agentens rolle, såsom planner, code-reviewer, eller test-writer.

4. Definér agentens metadata: I YAML-frontmatteren for den nyoprettede .agent.md fil konfigureres agentens egenskaber. Sæt en description (denne tekst vises som pladsholdertekst i chatinputtet, når agenten vælges), angiv den tools agenten skal have adgang til, og sæt eventuelt en foretrukket model eller konfigurér handoffs til andre agenter.

5. Skriv agentens instruktioner: I filens krop under YAML-frontmatteren skal du give de brugerdefinerede instruktioner til agenten. Disse instruktioner definerer agentens personlighed, ekspertise og adfærdsretningslinjer. Skriv dem i Markdown med klart, specifikt sprog, der fortæller AI'en, hvordan den skal gribe opgaverne an, hvad den skal fokusere på, og hvilke begrænsninger den skal følge.

6. Gem og aktiver: Gem filen. Den tilpassede agent vises straks i GitHub Copilot Chat-agenternes dropdown (forudsat user-invokable at er true, hvilket er standarden). Vælg agenten for at begynde at bruge den.

Agentfærdigheder

Agentfærdigheder er et beslægtet, men forskelligt begreb fra specialmæglere. Mens agenter definerer en persona med instruktioner og værktøjer, beskriver agentens færdigheder (defineret i SKILL.md filer) specifikke evner eller ekspertiseområder, som en agent kan trække på. Færdigheder giver struktureret metadata om, hvad en agent ved og kan gøre. Visual Studio Code understøtter færdigheder som en del af det bredere tilpasningssystem. Færdigheder defineres typisk i dit arbejdsområde og opdages automatisk af GitHub Copilot for at forbedre agenternes svar med specialiseret viden.

Eksempler på custom agents

Følgende eksempler illustrerer, hvordan man definerer agenter til almindelige udviklingsroller.

"Planlægger"-agent

En planlægger fokuserer på at analysere krav og generere implementeringsplaner uden at ændre nogen kode. Den bruger kun skrivebeskyttede værktøjer og inkluderer en overdragelse til en implementeringsagent, når planen er klar til at blive udført.

---
description: Generates high-level implementation plans without writing code
tools: ['search', 'read', 'fetch']
handoffs:
  - label: Start Implementation
    agent: implementer
    prompt: Now implement the plan outlined above.
    send: false
---
# Planner

You are a senior software architect. When the user describes a feature or change, analyze the request and generate a detailed implementation plan.

Your plan should include:
1. A summary of the feature requirements.
2. A list of files that need to be created or modified.
3. Step-by-step implementation tasks in logical order.
4. Any potential risks or considerations.

Do not write or modify any code. Focus on planning only. Ask clarifying questions if the requirements are ambiguous.

"Code Reviewer"-agent

En Code Reviewer-agent undersøger kode for kvalitetsproblemer, sikkerhedssårbarheder og overholdelse af bedste praksis. Den bruger læse- og søgeværktøjer, men redigerer ikke filer direkte.

---
description: Reviews code for bugs, security issues, and style compliance
tools: ['search', 'read']
---
# Code Reviewer

You are an experienced code reviewer. When the user asks you to review code, examine it for:

- Bugs and logical errors
- Security vulnerabilities (SQL injection, XSS, authentication flaws)
- Performance issues
- Naming convention violations
- Missing error handling
- Code duplication

Present your findings as a structured review with severity levels. For each issue, explain the problem, show the affected code, and suggest an improvement. End with an overall assessment of code quality.

Disse eksempler kan tilpasses til at matche dit teams specifikke behov. Nøgleprincippet er at definere klare instruktioner, der fokuserer agenten på en specifik opgave og konfigurere værktøjslisten, så den matcher agentens ansvar.

Opsamling

Brugerdefinerede agenter i Visual Studio Code lader dig definere specialiserede AI-personaer med tilpassede instruktioner og værktøjstilladelser. Ved at oprette .agent.md filer i dit arbejdsområde eller brugerprofil kan du bygge agenter til specifikke udviklingsroller – planlægning, implementering, gennemgang, test og mere. Hver agent arbejder inden for de grænser, du definerer, bruger kun de værktøjer, du tillader, og følger de instruktioner, du giver. Avancerede funktioner som underagenter, agenter på organisationsniveau og integration af MCP-servere udvider det, agenter kan opnå. Disse funktioner giver dig præcis kontrol over, hvordan GitHub Copilot opfører sig i forskellige faser af din udviklingsarbejdsgang.