# Parallelt Claude Code-arbeid: worktree, agenter og Workflows
> Fire lag med parallelt Claude Code-arbeid, isolering med git worktree, resultatverifisering, GUI-verktøy og grenser for arbeidsmengde og tokens.
Source: https://ailoot.ai/blog/nb/claude-code-parallel-worktree-agents/
Canonical: https://ailoot.ai/blog/nb/claude-code-parallel-worktree-agents/
Language: nb
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-179
Revision: sha256-d23416ac8ace495fabedf623ddbc561fc84c1089beee3d95bb8e221195354ad4
Viktige punkter
Claude Code tilbyr fire måter å dele arbeid mellom flere agenter på: subagenter i én økt, skills med instruksjoner, agentteam med en leder og separate vinduer, og Dynamic Workflows som et JavaScript-skript kjørt av runtime-miljøet. Hvis du vil ha mer enn fem Claude Code-instanser kjørende parallelt på én maskin, kan du bruke git worktree til å isolere filer. Den offisielle runtime-grensen er 16 agenter samtidig, 1000 per kjøring. Hovedfellen ligger ikke i koden. «Jeg har 50 agenter i arbeid» betyr som regel «50 agenter produserer tull parallelt uten at noen sjekker det». Outcomes — en rubrikk med kriterier og en uavhengig kontrolløragent — løser dette.
Praktisk materiale om å jobbe parallelt med agenter: [Ailoot-dokumentasjonen](https://ailoot.ai/docs/).
Denne guiden samler praktisk erfaring og en oversikt over hvor verktøyene passer. De fire offisielle Claude Code-primitivene, en oversikt over hvor de passer og et rammeverk mot overdrivelser om hvor mange parallelle agenter en vibe coder faktisk trenger. Alle tall og sitater lenker til primærkilder fra Anthropic.
## Hva er multi-agent i Claude Code, og hvorfor er det ikke «1000 agenter»
Viktige punkter
Multi-agent i Claude Code er enhver situasjon der flere arbeidsstrømmer håndterer en oppgave i stedet for én samtale. Det kan være flere økter i ulike vinduer, en leder med underordnede agenter i én økt eller et skript orkestrert av runtime-miljøet. «1000 agenter» er den tekniske øvre grensen for én Dynamic Workflow. Det er en sikkerhetsgrense mot en runtime-løkke som løper løpsk, ikke en anbefaling for arbeidsmengde.
Et multi-agent-oppsett er et oppsett der en oppgave deles i flere uavhengige arbeidsstrømmer. Hver av dem håndterer sin egen del og leverer et resultat tilbake. Det enkleste eksempelet: Du skriver frontend i ett Claude Code-vindu og backend i et annet vindu på samme maskin, med et delt git-repositorium mellom dem. Det er allerede multi-agent, selv om «orkestrering» ville vært et unødvendig stort ord for det.
Et mer omfattende oppsett: I én Claude Code-økt starter du fem subagenter med ulike roller (frontendutvikler, backendutvikler, sikkerhetskontrollør, tester, dokumentasjonsskribent), og hver agent leverer sin del av resultatet tilbake til den delte samtalen. Det er den samme multi-agent-tilnærmingen, bare med ett kontrollpunkt.
Et enda mer omfattende oppsett: Du sier til Claude: «kjør en ukentlig sikkerhetsrevisjon av alle 500 filene i prosjektet mitt», og Claude skriver et JavaScript-orkestreringsskript. Runtime-miljøet starter flere titalls agenter i bakgrunnen. Hver agent reviderer sin egen del, deretter kontrollerer uavhengige agenter hverandres funn, og du får én rapport tilbake. Dette er [Dynamic Workflows](https://ailoot.ai/blog/nb/claude-code-dynamic-workflows/), lansert av Anthropic 28. mai 2026. En detaljert gjennomgang av funksjonen finnes i [den separate guiden til Dynamic Workflows](https://ailoot.ai/blog/nb/claude-code-dynamic-workflows/).
Forskjellen mellom disse tre scenariene er ikke antallet agenter. Forskjellen er **hvem som bestemmer hva den neste agenten skal gjøre**. I det første scenariet er det deg. I det andre bestemmer Claude etter hvert som samtalen utvikler seg. I det tredje er det et JavaScript-skript som Claude har skrevet.
«1000 agenter» er for øvrig et reelt tall. Det er den øvre grensen for én Dynamic Workflow i Claude Code. Den [offisielle Anthropic-dokumentasjonen](https://code.claude.com/docs/en/workflows) sier:
Opptil 16 samtidige agenter, færre på maskiner med begrenset CPU. Totalt 1000 agenter per kjøring — for å forhindre løpske løkker.
— Anthropic Claude Code Docs, https://code.claude.com/docs/en/workflows
Med andre ord er dette et teknisk vern mot løpsk oppførsel, ikke en anbefalt arbeidsmengde. I praksis håndteres 95 % av oppgavene av 2–8 parallelle arbeidsstrømmer. Hvis du planlegger flere, bør du først spørre deg selv hva de skal gjøre.
## 4 Claude Code-primitiver: subagenter, skills, agentteam og workflows
Viktige punkter
Den offisielle Claude Code-dokumentasjonen beskriver fire ulike lag for multi-agent-arbeid. Subagenter er midlertidige arbeidere i én økt. Skills er instruksjoner Claude følger. Agentteam er faste «kolleger» i separate vinduer, med en leder. Workflows er skript som orkestreres av runtime-miljøet. Hvert lag har sin egen grense for samtidighet og et sted for mellomresultater.
Claude Code har fire offisielle primitiver for å dele én oppgave mellom flere agenter. Anthropic samlet dem i en sammenligningstabell i [dokumentasjonen for Dynamic Workflows](https://code.claude.com/docs/en/workflows). Her er sammenligningen forklart med vanlige ord:
| | Subagenter | Skills | Agentteam | Workflows |
|----|----|----|----|----|
| Hva det er | En arbeider Claude starter | Instruksjoner Claude følger | En leder med et team i separate vinduer | Et skript runtime-miljøet kjører |
| Hvem bestemmer trinnene | Claude etter hvert som samtalen utvikler seg | Claude ut fra instruksjonene | Lederen | Selve skriptet |
| Hvor resultatene ligger | I Claudes kontekstvindu | I kontekstvinduet | I en delt oppgaveliste | I skriptvariabler |
| Hva som kan gjenbrukes | Beskrivelsen av arbeideren | Instruksjonene i seg selv | Teamets beskrivelse | Hele orkestreringen |
| Omfang | Noen få om gangen | Samme antall | Noen få faste kolleger | Flere titalls og hundrevis per kjøring |
| Hva som skjer ved avbrudd | Turen starter på nytt | Turen starter på nytt | Kollegene fortsetter | Gjenopptas i samme økt |
Hvert av disse primitivene løser et ulikt problem. Subagenter er til å delegere 2–3 kontroller innenfor én oppgave. Skills er for tilfeller der du har ferdige instruksjoner Claude skal følge (som «gjennomgå en PR med denne sjekklisten»). Agentteam passer når flere deler av et produkt ligger i ulike vinduer og du trenger én koordinator. Workflows er for oppgaver som er for store for ett kontekstvindu.
Subagenter er grundig omtalt i [Claude Code Subagents 2026-guiden](https://ailoot.ai/blog/nb/claude-code-subagents/). Beslutningstreet for «hva du skal bruke til en bestemt oppgave» finnes i [guiden Skills, Subagents, MCP, Plugins](https://ailoot.ai/blog/nb/skills-subagents-mcp-plugins-claude-code/). Denne guiden handler om å sette dem sammen til et multi-agent-oppsett basert på git worktree.
## Nivå 1: subagenter i én økt — det enkleste stedet å begynne
Viktige punkter
En subagent er en midlertidig «arbeider» i en Claude-økt. Du ber hovedagenten «starte fire subagenter: frontendutvikler, backendutvikler, tester, dokumentasjonsskribent», og hver agent håndterer sin del og leverer resultatet tilbake til den delte samtalen. Samtidighet: 2–5 subagenter, alle innenfor én delt kontekst.
En subagent er den enkleste måten å dele en oppgave på. Hovedsamtalen er koordinatoren. Subagenter er midlertidige arbeidere hovedagenten starter etter hvert som arbeidet skrider fram.
Et konkret eksempel fra prosjektet som beskrives. Etter det første utkastet til en guide settes gjennomgangen opp slik: Claude får forespørselen «start seks subagenter parallelt — én sjekker etter AI-markører, den andre etter juridisk vokabular, den tredje etter stemme og tone, den fjerde sjekker fakta med WebFetch, den femte vurderer SEO-strukturen, og den sjette kontrollerer at krysslenkene er riktige». Hver agent leverer en rapport, og deretter gjennomføres endringene.
Teknisk gjøres dette med filer i `.claude/agents/[subagent-name].md` som beskriver rollen og verktøyene. Kallet gjøres via `Agent`-verktøyet i hovedsamtalen. Claude bestemmer når en forespørsel skal sendes til en subagent.
**Hvor det fungerer.** Oppgaver med 3–7 parallelle kontroller av ett artefakt (kode, tekst, design). Hver kontroll er uavhengig. Resultatene får plass i hovedkontekstvinduet.
**Hvor det begynner å svikte.** Hvis du har 50+ filer, eller hver kontroll trenger sin egen kontekst på 50K tokens, blir hovedvinduet fullt. Da trenger du workflows eller agentteam.
**Hovedrisiko.** Hver subagent bruker tokens separat. Hvis du starter seks for et prosjekt med 200 filer, og hver agent leser alle de 200 på nytt, betaler du 6×. Du MÅ derfor angi nøyaktig hvilke filer subagenten skal undersøke. Se [guiden Hvor tokenene tar veien i Claude Code](https://ailoot.ai/blog/nb/where-claude-code-tokens-go/) for mer informasjon.
## Nivå 2: git worktree — isolering av filer mellom parallelle økter
Viktige punkter
Subagenter deler én økt og ett filsystem. Hvis du vil at to fullverdige Claude Code-instanser i ulike terminaler skal redigere ett prosjekt, trenger de separate arbeidskopier. Git worktree gir deg det gratis: én sannhetskilde i `.git`, to uavhengige kataloger på disken.
Når subagenter ikke strekker til, og du trenger to fullverdige Claude Code-instanser i forskjellige terminaler som jobber på samme repository, oppstår et klassisk problem. De begynner å redigere den samme filen; den ene lagrer først, og den andre skriver over endringen. En kunde spurte supportteamet forrige uke: «5 overskriver hverandre samtidig.»
Løsningen er git worktree. Det er en innebygd git-funksjon som lar deg ha flere arbeidskopier av samme repository, hver på sin egen branch, med et delt `.git`-repository. Én opprinnelse, ulike kataloger på disken og ingen overlapping mellom filene. Mekanismen beskrives i detalj i [guiden Git worktree i Claude Code](https://ailoot.ai/blog/nb/claude-code-git-worktree/).
Kommandoer for et oppsett på fem minutter:
```bash
# Fra hovedkatalogen til prosjektet
cd ~/projects/my-app
# Opprett en worktree for feature/auth
git worktree add ../my-app-auth feature/auth
# Opprett en worktree for feature/billing
git worktree add ../my-app-billing feature/billing
# Åpne to terminalvinduer
cd ~/projects/my-app-auth && claude # første Claude Code
cd ~/projects/my-app-billing && claude # andre Claude Code
```
Hver kopi ligger på sin egen branch. Hver Claude Code-instans skriver i sin egen katalog. Når oppgaven er ferdig, kjører du `git push` fra branchen, og deretter `git worktree remove ../my-app-auth`.
**Dette bør du vite.** En worktree dupliserer ikke `node_modules`, `.venv` eller andre filer i `.gitignore`. Hvis du trenger uavhengige dependencies (en annen biblioteksversjon på hver branch), kjører du `npm install` separat i den nye katalogen etter `worktree add`.
**Hvor mange worktrees per person.** Basert på teamundersøkelser fra 2026 er den praktiske øvre grensen 4–8 parallelle worktrees per utvikler. Det som begrenser, er ikke Claude, men hvor mange resultater én person klarer å gjennomgå og godkjenne. Med 10 worktrees venter de på gjennomgang.
I praksisen som beskrives, bruker folk som regel 2–3 parallelle worktrees. Én primær worktree for aktivt arbeid, én reserve for hastende hotfixer og én for et eksperiment (en ny funksjon du er usikker på). Flere trengs ikke.
## Nivå 3: agentteam — flere vinduer, én ledende agent
Viktige punkter
Agentteam er flere Claude Code-instanser i ulike vinduer som jobber sammen som et team: én ledende agent følger en delt oppgaveliste, de andre rapporterer til den og kommuniserer gjennom et delt filsystem. Dette er et orkestreringsnivå mellom «subagenter i én samtale» og «Dynamic Workflows som kode».
Agentteam er en relativt ny primitiv. Ideen er at én ledende agent holder den delte planen som en oppgaveliste, og flere sidestilte økter i egne vinduer tar på seg oppgaver lederen har tildelt. Alle jobber i det samme filsystemet og kan se hverandres mellomresultater.
Dette er nyttig når en oppgave kan deles i 3–5 store arbeidsstrømmer som hver varer i flere timer (migrere en stor modul, skrive om et undersystem, gjennomføre en full sikkerhetsrevisjon). Lederen holder planen i én delt oppgavefil med absolutt bane utenfor worktrees. Arbeidere leser den banen og rapporterer resultater. Bare lederen oppdaterer status, slik at koordineringsfilen unngår konkurrerende skriving.
Teknisk sett er agentteam flere vinduer som kjører over git worktree med ett felles planleggingspunkt. I praksis styrer 80 % av folk agentteam manuelt (slik worktree-oppsettet ovenfor beskriver) og bruker ikke et eget «team-rammeverk». Det er helt greit.
Hvis du er usikker på om du trenger et rammeverk i det hele tatt, trenger du det nesten helt sikkert ikke. Bruk manuell worktree og én ledende agent i hovedkatalogen.
## Nivå 4: Dynamic Workflows — Claude skriver et JS-orkestreringsskript
Viktige punkter
En Dynamic Workflow er et JavaScript-skript Claude skriver for oppgaven din, og som runtime-miljøet kjører i bakgrunnen. Runtime-miljøet starter opptil 16 agenter om gangen (1000 per kjøring), mens økten forblir responsiv. Den kan aktiveres med nøkkelordet `workflow` i en prompt, innstillingen `/effort ultracode` eller den innebygde kommandoen `/deep-research`. Lansert 28. mai 2026; krever Claude Code v2.1.154+.
I alle de tre nivåene ovenfor ligger planen i en samtale: i hodet på hovedagenten eller i oppgavelisten til den ledende agenten. Dynamic Workflows flytter planen **inn i kode**. Claude uttrykker oppgaven som et JavaScript-skript, runtime-miljøet kjører det i et isolert miljø, mellomresultater ligger i skriptvariabler i stedet for i konteksten din, og økten forblir responsiv mens agentene jobber i bakgrunnen.
Et konkret eksempel fra den offisielle dokumentasjonen. Du sier:
```
ultracode: revider hvert API-endepunkt under src/routes/ for manglende auth-kontroller
```
Claude skriver et JavaScript-skript med omtrent denne logikken: hent alle filene fra `src/routes/`, del dem i grupper på 30 endepunkter, kjør en agent på hver gruppe med den samme kontrollen, kjør deretter to uavhengige graderingsagenter på funnene deres, og samle en sluttrapport. Skriptet kjører. Du får en resultattabell og en liste over endepunkter som helt klart trenger gjennomgang.
Hvor det fungerer.
- Revidere et helt prosjekt for ett problem (sikkerhet, typing, utdaterte API-er).
- Store migreringer (500+ filer som følger en felles regel).
- Forskningsspørsmål som må kontrolleres fra flere uavhengige vinkler (Anthropic gjør dette med den innebygde kommandoen `/deep-research`).
En detaljert gjennomgang av Dynamic Workflows, begrensningene deres og hvordan `ultracode` fungerer, står i [den separate guiden til Dynamic Workflows i Claude Code](https://ailoot.ai/blog/nb/claude-code-dynamic-workflows/).
**Når du IKKE bør bruke det.** Når oppgaven er lineær og tydelig. Du trenger ingen workflow for en oppgave som «fullfør denne komponenten». En workflow passer når en oppgave deles i 10+ uavhengige deloppgaver som må kryssjekkes.
**Hovedbegrensning.** En workflow bruker betydelig flere tokens enn en vanlig økt. Anthropic anbefaler i [dokumentasjonen](https://code.claude.com/docs/en/workflows):
Dynamic workflows kan bruke betydelig flere tokens enn en typisk Claude Code-økt, så vi anbefaler at du begynner med en oppgave av begrenset omfang.
— Anthropic Claude Code Docs, https://code.claude.com/docs/en/workflows
Med andre ord: Kjør den første workflowen på én katalog, ikke hele prosjektet. Se hva den kostet, og avgjør deretter om det er verdt å skalere opp.
## Outcomes: en rubrikk med kriterier og en uavhengig kontrollør
Viktige punkter
Det største multi-agent-problemet er at agenter produserer ting som SER ferdige ut. Et sitat virker sant, en rapport virker fullstendig. Outcomes fra Anthropic er en agent nummer to i en ny kontekst, som leser en rubrikk og kontrollerer arbeidet til den første agenten. Lansert 6. mai 2026 på Code with Claude. Funksjonen økte oppgavefullføringen 6× hos Harvey og reduserte gjennomgangstiden med 50 % hos Wisedocs.
Det farligste ved multi-agent-arbeid er **å stole på resultatene fra agentene**. Hver agent returnerer tekst som ser ut som ferdig arbeid. Et sitat virker sant, en rapport virker fullstendig, en migrering virker ferdig. Med én agent kan du kontrollere det selv. Med 10 kan du ikke — du har ikke tid.
Anthropic håndterer dette problemet med Outcomes, en Managed Agents-funksjon lansert 6. mai 2026. Ideen er enkel: Økten får en ANDRE agent (en graderer) som bare skal kontrollere arbeidet til den første agenten mot en streng rubrikk.
Slik fungerer det teknisk. Du skriver en rubrikk — et markdown-dokument med en detaljert liste over hva «ferdig» betyr, hvilke kilder som skal sjekkes, og hvilke etiketter som skal brukes. Plattformen oppretter automatisk en graderingsagent i et nytt kontekstvindu. Den mottar bare rubrikken og resultatet, ingenting annet. Etter hvert forsøk fra hovedagenten (skribenten) leser graderingsagenten resultatet på nytt og godkjenner det eller returnerer en punktvis liste over det som gjenstår.
Et sitat fra [Anthropic Cookbook](https://platform.claude.com/cookbook/managed-agents-cma-verify-with-outcome-grader):
Agenter er flinke til å produsere ting som SER ferdige ut. Be en agent lage en forskningsrapport med kildehenvisninger, og du får et polert dokument med fotnoter. Ser du nærmere etter, er emnet overfladisk behandlet, et sitat har beveget seg bort fra kilden, eller en kildehenvisning peker til en pressemelding i stedet for originaldokumentet.
— Anthropic Cookbook - Outcomes, https://platform.claude.com/cookbook/managed-agents-cma-verify-with-outcome-grader
Faktiske effekttall: Etter at Outcomes ble integrert i Claude Managed Agents, økte oppgavefullføringen hos AI-selskapet Harvey med omtrent 6×. Hos Wisedocs (medisinsk dokumentasjon) gikk tiden som ble brukt på å gjennomgå et dokument, ned med 50 %. Tallene kommer fra den offisielle kunngjøringen av funksjonen.
Hva som er viktig for en vibe coder, snarere enn en bedrift: Outcomes er et mønster, ikke bare en bestemt funksjon. Du kan lage din egen graderingsagent ved å beskrive de samme kriteriene i `.claude/agents/grader.md` og be hovedagenten kjøre den etter hvert forsøk. Dette fungerer med alle multi-agent-oppsett, ikke bare Managed Agents.
Hovedregelen fra Cookbook for å skrive rubrikker er **å spesifisere noe som kan verifiseres, ikke noe generelt**. Ikke «sjekk at briefen dekker fakturering», men «åpne briefen, finn delen om fakturering og bekreft at den angir et beløp i \$ eller en prosentandel av inntektene». Den første instruksjonen lar graderingsagenten skumlese og krysse av. Den andre får den til å åpne dokumentet og finne et bestemt tall.
## Antimønster: «50 agenter som gjør tull»
Viktige punkter
Den største feilen i ethvert parallelt oppsett er å starte mange agenter uten å forstå hva hver av dem gjør. I praksis var det maksimalt 2–3 parallelle arbeidsstrømmer da en AI-agent ble utviklet i løpet av 3–4 timer. Når en vibe coder skryter av «50 parallelt», betyr det vanligvis «50 agenter som lager søppel parallelt uten at noen kontrollerer det». Tegnet på dette er at du ikke kan forklare på 30 sekunder hvilken konkret oppgave hver agent løser.
Dette er det sentrale multi-agent-antimønsteret. Noen finner ut at Claude Code kan kjøre 16 agenter samtidig, og at Dynamic Workflows kan kjøre 1000 per kjøring, og setter seg ned for å starte dem. Resultat: null. Tokenforbruk: 10× en vanlig økt.
En enkel test. Ta et ark og tegn en boks for hver agent. Skriv følgende i hver boks:
1. Hva den gjør helt konkret (én setning).
2. Hvilke filer den berører.
3. Hva den leverer tilbake.
4. Hvem som kontrollerer det.
Hvis du ikke kan svare på bare ett av disse spørsmålene innen 30 sekunder, bør du ikke ha den agenten. Denne regelen gjelder på alle nivåer: subagenter, agentteam og Dynamic Workflows.
Det andre antimønsteret er **å kjøre arbeid parallelt som burde vært sekvensielt**. Hvis frontend trenger backend først fordi den leser API-skjemaet, skal du ikke kjøre dem parallelt. Gjør backend først og frontend etterpå. Oppgaver bør bare kjøres parallelt hvis de er **uavhengige**.
Det tredje antimønsteret er **å bruke multi-agent for å få høyere hastighet**. Det fungerer bare til et visst punkt. Hvis du deler en oppgave i fire uavhengige arbeidsstrømmer, blir de ferdige omtrent på den tiden det ville tatt for én strøm (pluss minimal koordineringstid). Men hvis 50 strømmer kjører på én maskin, går hver av dem langsommere fordi de deler CPU-en. Den praktiske grensen på en bærbar PC er 4–6 samtidige Claude Code-instanser; etter det begynner strupingen.
## Hva koster det, og hvordan unngår du å bruke opp grensene dine?
Viktige punkter
Et multi-agent-oppsett bruker flere ganger så mange tokens. Subagenter: 2×–4× en vanlig økt. Agentteam: 3×–6×. Dynamic Workflows: 10×–30×. Viktigste regler for å spare: angi filer for hver agent, ikke kjør en workflow over hele prosjektet på én gang, og sjekk kostnaden på en liten del.
I mai–juni 2026 måtte bransjen innse at AI-koding kostet mer enn forventet.
Én vanlig Claude Code-chatøkt koster et relativt rimelig beløp. Slår du på Dynamic Workflows for et helt repository, får du en regning som er 20× så høy. Fra den offisielle Anthropic-dokumentasjonen:
En workflow kjører mange agenter, så én kjøring kan bruke betydelig flere tokens enn det tar å utføre samme oppgave i en vanlig samtale. Prøv workflowen på en liten del for å forstå kostnaden før en stor kjøring.
— Anthropic Claude Code Docs, https://code.claude.com/docs/en/workflows
Hva bør du gjøre i praksis? Reglene for å spare fra den beskrevne praksisen:
1. **Angi nøyaktig hvilke filer hver agent skal undersøke.** Ikke «gå gjennom prosjektet og finn problemer», men «se på `src/auth/*.ts` og kontroller at hver funksjon validerer `userId`». Den andre prompten gir deg akkurat det arbeidet du betaler for.
2. **Prøv alltid en workflow på én katalog først.** Ikke hele `src/`. Start med `src/auth/`. Hvis du liker resultatet og forstår kostnaden, kan du rulle den ut bredere.
3. **Bruk `/effort high` som standard, og bare `ultracode` når det er et bevisst valg.** `/effort ultracode` betyr xhigh pluss automatisk orkestrering. Det er svært dyrt. Bruk det når en oppgave faktisk krever flere parallelle arbeidsstrømmer.
4. **Bytt til en mindre modell for subagenter der du kan.** Hvis seks subagenter gjennomgår én guide, trenger verken QA-agenten som leter etter AI, eller krysslenkekontrolløren Opus. Sonnet holder. Det reduserer bruken med 3–5×.
En grundig gjennomgang av tokenbesparelser finnes i [guiden Hvor tokenene tar veien i Claude Code](https://ailoot.ai/blog/nb/where-claude-code-tokens-go/) og [Slik unngår du å bruke opp Claude Code-grensene](https://ailoot.ai/blog/nb/claude-code-token-limits-saving/).
## Hvor du kan begynne i dag: en sjekkliste på 30 minutter
Viktige punkter
Du trenger ikke hoppe rett til Dynamic Workflows. Et grunnleggende multi-agent-oppsett tar 30 minutter: to worktrees, to terminaler og én sjekkliste for lederen i `tasks.md`. Det er nok for 80 % av scenarioene. De andre 20 % (en stor revisjon eller migrering) kommer naturlig etter et par uker.
1. ### Oppdater Claude Code til v2.1.154+
Dette er minimumsversjonen som støtter Dynamic Workflows. Kjør `claude update` i terminalen.
2. ### Aktiver Dynamic Workflows i /config
De er deaktivert som standard på Pro-abonnementet. Åpne `/config`, finn linjen «Dynamic workflows» og slå den på. De er allerede aktivert på Max, Team og Enterprise.
3. ### Opprett din første worktree
Kjør `git worktree add ../-experiment ` i hovedkatalogen til prosjektet. Åpne et nytt terminalvindu i den katalogen. Kjør `claude`.
4. ### Legg til en delt oppgaveliste
Bruk **én absolutt bane utenfor alle worktrees**. En `tasks.md` i hvert worktree er en separat fil og synkroniseres ikke automatisk. La lederøkten være eneste skriver. Arbeidere leser den delte listen og rapporterer resultater til lederen.
Opprett koordineringsmappe og oppgaveliste én gang:
```bash
mkdir -p "$HOME/projects/my-app-coordination"
printf '%s\n' '# Tasks' '- Auth: assigned to the auth worktree' '- Billing: assigned to the billing worktree' > "$HOME/projects/my-app-coordination/tasks.md"
```
I første terminal:
```bash
cd "$HOME/projects/my-app-auth"
printf 'Shared task list: %s\n' "$HOME/projects/my-app-coordination/tasks.md"
claude
```
I andre terminal:
```bash
cd "$HOME/projects/my-app-billing"
printf 'Shared task list: %s\n' "$HOME/projects/my-app-coordination/tasks.md"
claude
```
Gi begge agenter **samme utvidede absolutte bane skrevet ovenfor**: «Les denne delte oppgavelisten. Arbeid bare med tildelt oppgave og filer. Ikke rediger listen. Rapporter fullføring og blokkeringer til lederen, som eier oppdateringer.» Bekreft at begge kan lese nøyaktig den filen før arbeid starter. Et tillatelsesspørsmål må avklares for den banen. Oppgavelisten koordinerer status, mens kodeendringer fortsatt ligger i separate worktrees.
5. ### Jobb slik i én uke
Ikke installer en GUI-innpakning med en gang. Jobb manuelt med to worktrees i en uke. Du ser hva som mangler, og kan deretter velge et verktøy for et konkret problem.
6. ### Aktiver først da \`/effort ultracode\`
Velg én oppgave, for eksempel «finn alle API-endepunkter uten auth-kontroller i src/routes/». Aktiver `/effort ultracode`. Se hvilken workflow Claude skriver, hva den koster, og hvilket resultat den gir. Det er din første Dynamic Workflow.
## Hva du kan utforske videre: minne mellom økter, Code Review og Multi-Agent v2
Viktige punkter
Et grunnleggende multi-agent-oppsett håndterer 80 % av oppgavene. De tre neste funksjonene på vei er Managed Agents med Dreaming (minne mellom økter), Code Review utført av et agentteam på hver PR og Multi-Agent Orchestration v2 i Claude Agent SDK. Alle er i research preview, offentlig beta eller kun annonsert for begrenset tilgang.
Hva kom i mai–juni 2026, og hvilken retning tar multi-agent i Claude Code?
**Managed Agents med Dreaming.** Lansert 6. mai 2026 på Code with Claude. En planlagt prosess leser en agents tidligere transkripsjoner mellom øktene, identifiserer tilbakevendende mønstre og oppdaterer minnet. Oppgavefullføringen hos AI-juristselskapet Harvey økte seks ganger spesifikt etter Dreaming. Fortsatt i research preview.
**Outcomes som en Managed Agents-funksjon.** Beskrevet ovenfor. Tilgjengelig gjennom Claude Agent SDK, ikke direkte i Claude Code CLI. Du kan bruke samme mønster manuelt nå, med en graderingssubagent.
**Multi-Agent Orchestration v2 i Claude Agent SDK.** En ledende agent delegerer selv arbeid til subagenter ved hjelp av et delt filsystem. Dette er et steg fra «start N subagenter manuelt» til «beskriv en oppgave, så bestemmer lederen selv hvem den skal delegere til og hvordan». Hvis du akkurat har begynt å lære om subagenter, trenger du ikke bekymre deg for v2 ennå. Lær det klassiske mønsteret — «én hovedagent + 3–5 subagenter med roller» — og gå naturlig videre til v2 om 3–6 måneder.
**Code Review utført av et agentteam.** Anthropic kunngjorde en funksjon på Code with Claude for automatisk kodegjennomgang når en PR åpnes. Et team av AI-agenter kontrollerer diffen parallelt, leter etter feil, verifiserer funn med hverandre og rangerer dem etter alvorlighetsgrad. Tilgjengelig på Team og Enterprise, foreløpig ikke på Pro.
**Plugin Marketplace.** Lansert 23. mai 2026 i v2.1.128-136. Noen marketplace-plugins er ferdige multi-agent-oppsett (parallel-review, security-audit, migration-helper). Du kan installere dem med `/plugin install @claude-plugins-official` og se hvordan de er satt sammen — en god måte å lære å skrive dine egne på.
Multi-agent i Claude Code er fremdeles en samling primitiver på forskjellige modenhetsnivåer. Subagenter og git worktree er stabile, velprøvde og fungerer overalt. Agentteam er halvautomatiserte og halvmanuelle. Dynamic Workflows er i research preview og endres raskt. Managed Agents v2 er bare for bedrifter. Det betyr at det optimale oppsettet for en vibe coder det neste året ikke vil være **den nyeste versjonen**, men det minimale oppsettet som trengs for den konkrete oppgaven. To worktrees og én graderingssubagent er nok til en måned med aktivt arbeid. Legg bare til kompleksitet når du begynner å merke begrensningene.
## Et fungerende oppsett for vibe coding
Viktige punkter
Et multi-agent-oppsett fungerer bare når det bygger på bevisst kontekstutvikling. Uten dette blir all parallell orkestrering til antimønsteret «50 agenter som gjør tull».
### Kilder
- [Anthropic - Orkestrer subagenter i stor skala med dynamic workflows (offisiell dokumentasjon)](https://code.claude.com/docs/en/workflows)
- [Anthropic - Vi introduserer Dynamic Workflows i Claude Code](https://claude.com/blog/introducing-dynamic-workflows-in-claude-code)
- [Anthropic Cookbook - Outcomes: agenter som verifiserer sitt eget arbeid](https://platform.claude.com/cookbook/managed-agents-cma-verify-with-outcome-grader)
- [Anthropic - Nytt i Claude Managed Agents (Dreaming, Outcomes, Multi-Agent v2)](https://claude.com/blog/new-in-claude-managed-agents)
- [Claude Code - Kjør agenter parallelt (dokumentasjon om subagenter og agentteam)](https://code.claude.com/docs/en/agents)
Flere materialer og verktøy: [Ailoot](https://ailoot.ai/).
## Spørsmål om denne veiledningen: Parallelt Claude Code-arbeid: worktree, agenter og Workflows | Ailoot
### Hvorfor viser to worktrees ulike tasks.md-filer?
Hvert worktree har egne filer. Legg koordineringslisten på én absolutt bane utenfor begge worktrees, gi samme utvidede bane til hver agent og verifiser at begge kan lese den før start.
### Hvem bør oppdatere den delte oppgavelisten?
Tildel én lederøkt som eneste skriver. Arbeidere leser listen, redigerer bare tildelte worktree-filer og rapporterer resultater eller blokkeringer til lederen. En delt bane alene hindrer ikke samtidige endringer.
## Ailoot · Selskapet og dets prosjektportefølje
Ailoot bygger på etablert driftserfaring, en stor kundebase, stabil tjeneste og løpende KPI-kontroll.
Selskapet og dets prosjektportefølje: millioner av kunder; månedlig salg for milliarder.
Ailoot bruker denne driftserfaringen til API-tilgang til AI-funksjoner i kundenes produkter, agenter, applikasjoner og automatiseringer.