---
title: Agenter
description: Konfigurer og bruk spesialiserte agenter.
---

Agenter er spesialiserte AI-assistenter som kan konfigureres for spesifikke oppgaver og arbeidsflyter. De lar deg lage fokuserte verktøy med tilpassede meldinger, modeller og verktøytilgang.

:::tip
Bruk planagenten til å analysere kode og gjennomgå forslag uten å gjøre noen kodeendringer.
:::

Du kan bytte mellom agenter under en økt eller påkalle dem med `@`-omtalen.

---

## Typer

Det er to typer agenter i OpenCode; primære agenter og underagenter.

---

### Primæragenter

Primæragenter er de viktigste assistentene du samhandler direkte med. Du kan bla gjennom dem ved å bruke **Tab**-tasten, eller din konfigurerte `switch_agent`-tastebinding. Disse agentene håndterer hovedsamtalen din. Verktøytilgang konfigureres via tillatelser - for eksempel har Build alle verktøy aktivert mens Plan er begrenset.

:::tip
Du kan bruke **Tab**-tasten for å bytte mellom primære agenter under en økt.
:::

OpenCode kommer med to innebygde primære agenter, **Build** og **Plan**. Vi ser nærmere på disse nedenfor.

---

### Underagenter

Underagenter er spesialiserte assistenter som primære agenter kan påkalle for spesifikke oppgaver. Du kan også starte dem manuelt ved å **@ nevne** dem i meldingene dine.

OpenCode kommer med to innebygde underagenter, **General** og **Explore**. Vi skal se på dette nedenfor.

---

## Innebygd

OpenCode kommer med to innebygde primære agenter og to innebygde underagenter.

---

### Bruk av Build

_Modus_: `primary`

Build er **standard** primæragent med alle verktøy aktivert. Dette er standardagenten for utviklingsarbeid der du trenger full tilgang til filoperasjoner og systemkommandoer.

---

### Bruk av Plan

_Modus_: `primary`

En begrenset agent designet for planlegging og analyse. Vi bruker et tillatelsessystem for å gi deg mer kontroll og forhindre utilsiktede endringer.
Som standard er alt av følgende satt til `ask`:

- `file edits`: Alle skrivinger, patcher og redigeringer
- `bash`: Alle bash-kommandoer

Denne agenten er nyttig når du vil at LLM skal analysere kode, foreslå endringer eller lage planer uten å gjøre noen faktiske endringer i kodebasen.

---

### Bruk av General

_Modus_: `subagent`

En generell agent for å undersøke komplekse spørsmål og utføre flertrinnsoppgaver. Har full verktøytilgang (unntatt todo), slik at den kan gjøre filendringer når det er nødvendig. Bruk denne til å kjøre flere arbeidsenheter parallelt.

---

### Bruk av Explore

_Modus_: `subagent`

En rask, skrivebeskyttet agent for å utforske kodebaser. Kan ikke endre filer. Bruk dette når du raskt trenger å finne filer etter mønstre, søke i kode etter nøkkelord eller svare på spørsmål om kodebasen.

---

### Bruk av Compaction

_Modus_: `primary`

Skjult systemagent som komprimerer lang kontekst til et mindre sammendrag. Den kjører automatisk ved behov og kan ikke velges i UI.

---

### Bruk av Title

_Modus_: `primary`

Skjult systemagent som genererer korte økttitler. Den kjører automatisk og kan ikke velges i UI.

---

### Bruk av Summary

_Modus_: `primary`

Skjult systemagent som lager øktsammendrag. Den kjører automatisk og kan ikke velges i UI.

---

## Bruk

1. For primære agenter, bruk **Tab**-tasten for å bla gjennom dem under en økt. Du kan også bruke din konfigurerte `switch_agent` nøkkelbinding.

2. Underagenter kan påkalles:
   - **Automatisk** av primære agenter for spesialiserte oppgaver basert på deres beskrivelser.
   - Manuelt ved å **@ nevne** en underagent i meldingen. For eksempel.

     ```txt frame="none"
     @general help me search for this function
     ```

3. **Navigering mellom økter**: Når underagenter oppretter sine egne underordnede økter, kan du navigere mellom overordnede økter og alle underordnede økter ved å bruke:
   - **\<Leader>+Right** (eller din konfigurerte `session_child_cycle`-tastebinding) for å gå videre gjennom forelder → barn1 → barn2 → ... → forelder
   - **\<Leader>+Left** (eller din konfigurerte `session_child_cycle_reverse`-tastebinding) for å gå bakover gjennom forelder ← barn1 ← barn2 ← ... ← forelder

   Dette lar deg sømløst bytte mellom hovedsamtalen og spesialisert underagentarbeid.

---

## Konfigurasjon

Du kan tilpasse de innebygde agentene eller lage dine egne gjennom konfigurasjon. Agenter kan konfigureres på to måter:

---

### JSON

Konfigurer agenter i konfigurasjonsfilen `opencode.json`:

```json title="opencode.json"
{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "build": {
      "mode": "primary",
      "model": "anthropic/claude-sonnet-4-20250514",
      "prompt": "{file:./prompts/build.txt}",
      "tools": {
        "write": true,
        "edit": true,
        "bash": true
      }
    },
    "plan": {
      "mode": "primary",
      "model": "anthropic/claude-haiku-4-20250514",
      "tools": {
        "write": false,
        "edit": false,
        "bash": false
      }
    },
    "code-reviewer": {
      "description": "Reviews code for best practices and potential issues",
      "mode": "subagent",
      "model": "anthropic/claude-sonnet-4-20250514",
      "prompt": "You are a code reviewer. Focus on security, performance, and maintainability.",
      "tools": {
        "write": false,
        "edit": false
      }
    }
  }
}
```

---

### Markdown

Du kan også definere agenter ved å bruke markdown-filer. Plasser dem i:

- Globalt: `~/.config/opencode/agents/`
- Per prosjekt: `.opencode/agents/`

```markdown title="~/.config/opencode/agents/review.md"
---
description: Reviews code for quality and best practices
mode: subagent
model: anthropic/claude-sonnet-4-20250514
temperature: 0.1
tools:
  write: false
  edit: false
  bash: false
---

You are in code review mode. Focus on:

- Code quality and best practices
- Potential bugs and edge cases
- Performance implications
- Security considerations

Provide constructive feedback without making direct changes.
```

Markdown-filnavnet blir agentnavnet. For eksempel oppretter `review.md` en `review`-agent.

---

## Alternativer

La oss se på disse konfigurasjonsalternativene i detalj.

---

### Beskrivelse

Bruk alternativet `description` for å gi en kort beskrivelse av hva agenten gjør og når den skal brukes.

```json title="opencode.json"
{
  "agent": {
    "review": {
      "description": "Reviews code for best practices and potential issues"
    }
  }
}
```

Dette er et **obligatorisk** konfigurasjonsalternativ.

---

### Temperatur

Kontroller tilfeldigheten og kreativiteten til LLMs svar med `temperature`-konfigurasjonen.

Lavere verdier gjør svarene mer fokuserte og deterministiske, mens høyere verdier øker kreativiteten og variasjonen.

```json title="opencode.json"
{
  "agent": {
    "plan": {
      "temperature": 0.1
    },
    "creative": {
      "temperature": 0.8
    }
  }
}
```

Temperaturverdier varierer vanligvis fra 0,0 til 1,0:

- **0.0-0.2**: Veldig fokuserte og deterministiske svar, ideell for kodeanalyse og planlegging
- **0,3-0,5**: Balanserte svar med litt kreativitet, bra for generelle utviklingsoppgaver
- **0.6-1.0**: Mer kreative og varierte svar, nyttig for idédugnad og utforskning

```json title="opencode.json"
{
  "agent": {
    "analyze": {
      "temperature": 0.1,
      "prompt": "{file:./prompts/analysis.txt}"
    },
    "build": {
      "temperature": 0.3
    },
    "brainstorm": {
      "temperature": 0.7,
      "prompt": "{file:./prompts/creative.txt}"
    }
  }
}
```

Hvis ingen temperatur er spesifisert, bruker OpenCode modellspesifikke standardinnstillinger; typisk 0 for de fleste modeller, 0,55 for Qwen-modeller.

---

### Maks trinn

Kontroller det maksimale antallet agentiske iterasjoner en agent kan utføre før den blir tvunget til å svare kun med tekst. Dette lar brukere som ønsker å kontrollere kostnadene sette en grense for agenthandlinger.

Hvis dette ikke er satt, vil agenten fortsette å iterere til modellen velger å stoppe eller brukeren avbryter økten.

```json title="opencode.json"
{
  "agent": {
    "quick-thinker": {
      "description": "Fast reasoning with limited iterations",
      "prompt": "You are a quick thinker. Solve problems with minimal steps.",
      "steps": 5
    }
  }
}
```

Når grensen er nådd, mottar agenten en spesiell systemmelding som instruerer den om å svare med en oppsummering av arbeidet og anbefalte gjenværende oppgaver.

:::caution
Det gamle `maxSteps`-feltet er avviklet. Bruk `steps` i stedet.
:::

---

### Deaktiver

Sett til `true` for å deaktivere agenten.

```json title="opencode.json"
{
  "agent": {
    "review": {
      "disable": true
    }
  }
}
```

---

### Ledetekst

Spesifiser en tilpasset systemmeldingsfil for denne agenten med `prompt`-konfigurasjonen. Ledetekstfilen skal inneholde instruksjoner som er spesifikke for agentens formål.

```json title="opencode.json"
{
  "agent": {
    "review": {
      "prompt": "{file:./prompts/code-review.txt}"
    }
  }
}
```

Denne banen er i forhold til hvor konfigurasjonsfilen er plassert. Så dette fungerer for både den globale OpenCode-konfigurasjonen og den prosjektspesifikke konfigurasjonen.

---

### Modell

Bruk `model`-konfigurasjonen for å overstyre modellen for denne agenten. Nyttig for bruk av ulike modeller optimalisert for ulike oppgaver. For eksempel en raskere modell for planlegging, en mer kapabel modell for implementering.

:::tip
Hvis du ikke spesifiserer en modell, bruker primæragenter [modell globalt konfigurert](/docs/config#models) mens subagenter vil bruke modellen til primæragenten som påkalte subagenten.
:::

```json title="opencode.json"
{
  "agent": {
    "plan": {
      "model": "anthropic/claude-haiku-4-20250514"
    }
  }
}
```

Modellen ID i OpenCode-konfigurasjonen din bruker formatet `provider/model-id`. For eksempel, hvis du bruker [OpenCode Zen](/docs/zen), vil du bruke `opencode/gpt-5.1-codex` for GPT 5.1 Codex.

---

### Verktøy

Kontroller hvilke verktøy som er tilgjengelige i denne agenten med `tools`-konfigurasjonen. Du kan aktivere eller deaktivere spesifikke verktøy ved å sette dem til `true` eller `false`.

```json title="opencode.json" {3-6,9-12}
{
  "$schema": "https://opencode.ai/config.json",
  "tools": {
    "write": true,
    "bash": true
  },
  "agent": {
    "plan": {
      "tools": {
        "write": false,
        "bash": false
      }
    }
  }
}
```

:::note
Den agentspesifikke konfigurasjonen overstyrer den globale konfigurasjonen.
:::

Du kan også bruke jokertegn for å kontrollere flere verktøy samtidig. For eksempel, for å deaktivere alle verktøy fra en MCP-server:

```json title="opencode.json"
{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "readonly": {
      "tools": {
        "mymcp_*": false,
        "write": false,
        "edit": false
      }
    }
  }
}
```

[Finn ut mer om verktøy](/docs/tools).

---

### Tillatelser

Du kan konfigurere tillatelser for å administrere hvilke handlinger en agent kan utføre. For øyeblikket kan tillatelsene for verktøyene `edit`, `bash` og `webfetch` konfigureres til:

- `"ask"` — Be om godkjenning før du kjører verktøyet
- `"allow"` — Tillat alle operasjoner uten godkjenning
- `"deny"` — Deaktiver verktøyet

```json title="opencode.json"
{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "edit": "deny"
  }
}
```

Du kan overstyre disse tillatelsene per agent.

```json title="opencode.json" {3-5,8-10}
{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "edit": "deny"
  },
  "agent": {
    "build": {
      "permission": {
        "edit": "ask"
      }
    }
  }
}
```

Du kan også angi tillatelser i Markdown-agenter.

```markdown title="~/.config/opencode/agents/review.md"
---
description: Code review without edits
mode: subagent
permission:
  edit: deny
  bash:
    "*": ask
    "git diff": allow
    "git log*": allow
    "grep *": allow
  webfetch: deny
---

Only analyze code and suggest changes.
```

Du kan angi tillatelser for spesifikke bash-kommandoer.

```json title="opencode.json" {7}
{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "build": {
      "permission": {
        "bash": {
          "git push": "ask",
          "grep *": "allow"
        }
      }
    }
  }
}
```

Dette kan ta et globmønster.

```json title="opencode.json" {7}
{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "build": {
      "permission": {
        "bash": {
          "git *": "ask"
        }
      }
    }
  }
}
```

Og du kan også bruke jokertegnet `*` for å administrere tillatelser for alle kommandoer.
Siden den siste samsvarsregelen har forrang, setter du jokertegnet `*` først og spesifikke regler etter.

```json title="opencode.json" {8}
{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "build": {
      "permission": {
        "bash": {
          "*": "ask",
          "git status *": "allow"
        }
      }
    }
  }
}
```

[Finn ut mer om tillatelser](/docs/permissions).

---

### Modus

Kontroller agentens modus med `mode`-konfigurasjonen. Alternativet `mode` brukes til å bestemme hvordan agenten kan brukes.

```json title="opencode.json"
{
  "agent": {
    "review": {
      "mode": "subagent"
    }
  }
}
```

Alternativet `mode` kan settes til `primary`, `subagent` eller `all`. Hvis ingen `mode` er spesifisert, er den standard til `all`.

---

### Skjult

Skjul en underagent fra `@` autofullføringsmenyen med `hidden: true`. Nyttig for interne underagenter som bare skal påkalles programmatisk av andre agenter via oppgaveverktøyet.

```json title="opencode.json"
{
  "agent": {
    "internal-helper": {
      "mode": "subagent",
      "hidden": true
    }
  }
}
```

Dette påvirker kun brukersynlighet i autofullfør-menyen. Skjulte agenter kan fortsatt påkalles av modellen via oppgaveverktøyet hvis tillatelser tillater det.

:::note
Gjelder kun `mode: subagent`-agenter.
:::

---

### Oppgavetillatelser

Kontroller hvilke subagenter en agent kan påkalle via oppgaveverktøyet med `permission.task`. Bruker glob-mønstre for fleksibel matching.

```json title="opencode.json"
{
  "agent": {
    "orchestrator": {
      "mode": "primary",
      "permission": {
        "task": {
          "*": "deny",
          "orchestrator-*": "allow",
          "code-reviewer": "ask"
        }
      }
    }
  }
}
```

Når den er satt til `deny`, fjernes subagenten fullstendig fra oppgaveverktøybeskrivelsen, så modellen vil ikke forsøke å starte den.

:::tip
Reglene evalueres i rekkefølge, og den **siste samsvarsregelen vinner**. I eksemplet ovenfor samsvarer `orchestrator-planner` med både `*` (avslå) og `orchestrator-*` (tillat), men siden `orchestrator-*` kommer etter `*`, er resultatet `allow`.
:::

:::tip
Brukere kan alltid starte en hvilken som helst underagent direkte via `@` autofullføringsmenyen, selv om agentens oppgavetillatelser ville nekte det.
:::

---

### Farge

Tilpass agentens visuelle utseende i UI med alternativet `color`. Dette påvirker hvordan agenten vises i grensesnittet.

Bruk en gyldig sekskantfarge (f.eks. `#FF5733`) eller temafarge: `primary`, `secondary`, `accent`, `success`, `warning`, `error`, `info`.

```json title="opencode.json"
{
  "agent": {
    "creative": {
      "color": "#ff6b6b"
    },
    "code-reviewer": {
      "color": "accent"
    }
  }
}
```

---

### Top P

Kontroller responsmangfoldet med alternativet `top_p`. Alternativ til temperatur for å kontrollere tilfeldighet.

```json title="opencode.json"
{
  "agent": {
    "brainstorm": {
      "top_p": 0.9
    }
  }
}
```

Verdiene varierer fra 0,0 til 1,0. Lavere verdier er mer fokuserte, høyere verdier mer mangfoldige.

---

### Ekstra

Eventuelle andre alternativer du spesifiserer i agentkonfigurasjonen vil bli **overført direkte** til leverandøren som modellalternativer. Dette lar deg bruke leverandørspesifikke funksjoner og parametere.

For eksempel, med OpenAIs resonneringsmodeller kan du kontrollere resonnementinnsatsen:

```json title="opencode.json" {6,7}
{
  "agent": {
    "deep-thinker": {
      "description": "Agent that uses high reasoning effort for complex problems",
      "model": "openai/gpt-5",
      "reasoningEffort": "high",
      "textVerbosity": "low"
    }
  }
}
```

Disse tilleggsalternativene er modell- og leverandørspesifikke. Sjekk leverandørens dokumentasjon for tilgjengelige parametere.

:::tip
Kjør `opencode models` for å se en liste over tilgjengelige modeller.
:::

---

## Opprette agenter

Du kan opprette nye agenter ved å bruke følgende kommando:

```bash
opencode agent create
```

Denne interaktive kommandoen vil:

1. Spør hvor du skal lagre agenten; global eller prosjektspesifikk.
2. Beskrivelse av hva agenten skal gjøre.
3. Generer en passende systemmelding og identifikator.
4. La deg velge hvilke verktøy agenten har tilgang til.
5. Lag til slutt en nedmerkingsfil med agentkonfigurasjonen.

---

## Bruksområder

Her er noen vanlige bruksområder for forskjellige agenter.

- **Byggagent**: Fullstendig utviklingsarbeid med alle verktøy aktivert
- **Planagent**: Analyse og planlegging uten å gjøre endringer
- **Kodevurderingsagent**: Kodegjennomgang med skrivebeskyttet tilgang pluss dokumentasjonsverktøy
- **Feilsøkingsagent**: Fokusert på etterforskning med bash og leseverktøy aktivert
- **Dokumentasjonsagent**: Dokumentasjonsskriving med filoperasjoner, men ingen systemkommandoer

---

## Eksempler

Her er noen eksempler på agenter du kan finne nyttige.

:::tip
Har du en agent du vil dele? [Send inn en PR](https://github.com/anomalyco/opencode).
:::

---

### Dokumentasjonsagent

```markdown title="~/.config/opencode/agents/docs-writer.md"
---
description: Writes and maintains project documentation
mode: subagent
tools:
  bash: false
---

You are a technical writer. Create clear, comprehensive documentation.

Focus on:

- Clear explanations
- Proper structure
- Code examples
- User-friendly language
```

---

### Sikkerhetsrevisor

```markdown title="~/.config/opencode/agents/security-auditor.md"
---
description: Performs security audits and identifies vulnerabilities
mode: subagent
tools:
  write: false
  edit: false
---

You are a security expert. Focus on identifying potential security issues.

Look for:

- Input validation vulnerabilities
- Authentication and authorization flaws
- Data exposure risks
- Dependency vulnerabilities
- Configuration security issues
```
