Zed er ikke længere bare “den hurtige editor Atom-holdet byggede i Rust”. I løbet af 2026 har Zed fået et fuldt AI-agent-lag oven på det GPU-accelererede fundament: en indbygget forudsigelsesmodel ved navn Zeta, et Agent Panel der kan læse og skrive filer på egen hånd, og en funktion kaldet Parallel Agents, hvor flere AI-agenter arbejder samtidigt i samme projekt. For danske og nordiske udviklere, der allerede bruger Cursor eller GitHub Copilot, er spørgsmålet blevet: kan en editor bygget til hastighed også holde trit på AI-fronten? Denne guide viser dig præcis hvordan du installerer Zed, kobler dine egne API-nøgler eller lokale modeller på, og bygger et fungerende AI-drevet workflow fra bunden.

Vi gennemgår 11 konkrete trin, fra installation til et komplet mini-projekt, med kodeeksempler du kan kopiere direkte ind i din settings.json. Undervejs ser vi på almindelige faldgruber, en fejlfindingsguide til de problemer der oftest rammer nye brugere, og en ærlig sammenligning med Cursor og GitHub Copilot. Sæt cirka 45 minutter af, så har du en fuldt konfigureret AI-editor klar til dit næste projekt.

Guiden er skrevet til dig, der allerede koder til dagligt, og som overvejer at supplere eller erstatte din nuværende editor med noget hurtigere. Du behøver ikke opgive dine eksisterende AI-abonnementer for at prøve Zed, de fleste opsætninger nedenfor kan køre parallelt med Cursor eller VS Code på samme maskine, så du kan sammenligne dem side om side på et rigtigt projekt, før du beslutter dig.

Hvad er Zed Editor, og hvorfor taler udviklere om det i 2026?

Zed er en kode-editor skrevet i Rust af holdet bag Atom og Tree-sitter. Den bruger sin egen GPU-accelererede renderingsmotor, GPUI, og sigter efter et andet mål end de fleste konkurrenter: rå hastighed. Editoren tegner grænsefladen ved 120 billeder i sekundet, og det mærkes så snart du åbner et stort projekt eller lader en AI-agent redigere 50 filer på én gang, du ser hver ændring i det øjeblik den sker.

Det AI-lag der er bygget oven på editoren, hedder samlet set “Zed AI”, og det består af fire dele: Agentic Editing (agenten løser opgaver selvstændigt), Edit Prediction via Zeds egen model Zeta, en Inline Assistant til hurtige rettelser direkte i koden, og Threads (samtalebaserede paneler knyttet til projekter og terminaler). Zed er samtidig open source, og det gælder også Zeta-modellen og den underliggende Agent Client Protocol (ACP), som gør det muligt at koble eksterne agenter som Claude Agent, Codex eller OpenCode direkte ind i editoren.

Det, der adskiller Zed fra Cursor og GitHub Copilot, er filosofien om modelfrihed. Du kan bruge Zeds egne hostede modeller, tilslutte dine egne API-nøgler fra Anthropic, OpenAI, Google AI, Mistral, DeepSeek, xAI, Amazon Bedrock, OpenRouter og flere, eller køre alt lokalt via Ollama eller LM Studio uden at en eneste kodelinje forlader din maskine. Den fleksibilitet er kernen i resten af denne guide.

Ifølge flere uafhængige anmeldelser fra 2026 nåede Zed version 1.0 tidligere på året, og udviklingstempoet er højt: Zeds offentlige changelog viser løbende tilføjelser som understøttelse af Gemini 3.7 Flash og selvhostede “Sweep”-modeller til edit prediction, ofte flere gange om ugen. Det gør Zed til et bevægeligt mål at skrive om, men også et af de værktøjer, hvor nye AI-modeller typisk lander hurtigt efter deres officielle lancering hos udbyderne selv.

Forudsætninger: dette skal du bruge, før du starter

Du behøver ikke meget for at komme i gang, men følgende gør processen glattere:

  • macOS 12 (Monterey) eller nyere, Windows 10/11, eller en 64-bit Linux-distribution (Ubuntu, Arch, Debian, RHEL/Fedora og lignende understøttes officielt)
  • Mindst 8 GB RAM, gerne 16 GB, hvis du vil køre en lokal AI-model via Ollama parallelt med editoren
  • En internetforbindelse til download og til cloud-baserede AI-modeller (springes over, hvis du udelukkende kører lokalt)
  • Valgfrit, men anbefalet: en API-nøgle fra Anthropic, OpenAI eller Google AI, hvis du vil bruge Bring Your Own Key (BYOK) i stedet for Zeds egne hostede modeller
  • Valgfrit: Ollama installeret, hvis du vil køre modeller helt lokalt (vi installerer det i trin 6)
  • Git installeret, så du kan åbne et rigtigt projekt og se agenterne arbejde med versionsstyring

Har du prøvet VS Code med Copilot eller Cursor før, vil meget af terminologien i denne guide (agent-paneler, inline-forslag, MCP-servere) allerede være genkendelig. Zed genbruger de fleste af de samme koncepter, bare i sin egen hurtigere indpakning.

Trin 1: Installer Zed på macOS, Windows eller Linux

Installationen tager under to minutter uanset platform. På macOS er den hurtigste vej Homebrew:

brew install --cask zed

På Windows bruger du winget fra en terminal:

winget install -e --id ZedIndustries.Zed

På Linux er installationsscriptet den enkleste metode, og det virker på både x86_64 og AArch64:

curl -f https://zed.dev/install.sh | sh

Vil du følge preview-kanalen i stedet for stable, som typisk ligger omkring en uge foran med nye funktioner, tilføjer du ZED_CHANNEL=preview foran kommandoen. Linux-installationen kræver en Vulkan 1.3-driver, så har du en ældre GPU eller kører i et virtuelt miljø uden GPU-adgang, kan du støde på renderingsfejl allerede her, det vender vi tilbage til i fejlfindingsafsnittet. Efter installationen finder du fulde systemkrav og distributions-noter i den officielle installationsdokumentation.

Trin 2: Første opstart og grundlæggende indstillinger

Første gang du åbner Zed, bliver du budt velkommen med en kort onboarding, hvor du kan vælge tema (lyst, mørkt eller systemstyret), tastaturprofil (Zeds egen, VS Code-lignende, Vim eller Helix), og om du vil logge ind med en Zed-konto. Login er ikke påkrævet for at bruge editoren som ren kodeeditor, men det er nødvendigt, hvis du vil bruge Zeds hostede AI-modeller uden selv at skulle indsætte API-nøgler.

Al konfiguration i Zed foregår i en JSON-fil kaldet settings.json. Du åbner den hurtigst med kommandopaletten (Cmd+Shift+P på macOS eller Ctrl+Shift+P på Windows/Linux) og søger efter “zed: open settings”. De fleste AI-relaterede indstillinger kan du også nå via menuen Settings → AI, men når du skal lave mere specifikke opsætninger, som dem vi laver i trin 5 og 6, er det hurtigere at redigere filen direkte.

Kom i gang med et minimalt tema- og fontopsæt, så du har noget at bygge videre på:

{
  "theme": "One Dark",
  "buffer_font_family": "Zed Mono",
  "buffer_font_size": 14,
  "vim_mode": false,
  "autosave": "on_focus_change"
}

Trin 3: Åbn dit projekt og lær grænsefladen at kende

Åbn en mappe med File → Open Folder, eller kør zed . fra terminalen inde i dit projekt. Zeds grænseflade minder om VS Codes ved første øjekast, med et projektpanel til venstre og editoren i midten, men lægger du mærke til det, er der to paneler der er unikke for AI-arbejdet: Agent Panel og Threads Sidebar.

Du skifter mellem “Classic Layout” (editor-fokuseret, ligesom du kender fra andre editorer) og “Agentic Layout” via brugermenuen i titellinjen. Agentic Layout placerer Agent Panel og Threads Sidebar til venstre, mens projektpanel og Git-panel flyttes til højre, en opsætning der giver mere mening, når du arbejder tæt sammen med flere agenter på samme tid, hvilket vi kommer til i trin 8. Threads Sidebar åbner du med genvejen Cmd+Alt+J (macOS) eller Ctrl+Alt+J (Windows/Linux).

Trin 4: Forstå Zeta, Zeds indbyggede forudsigelsesmodel

Zeta er navnet på Zeds egen “edit prediction”-model. Den adskiller sig fra almindelig autocomplete ved at forudsige din næste redigering snarere end blot næste token. Det betyder, at Zeta ofte kan foreslå en flerlinjers omskrivning af en funktion som ét samlet Tab-forslag, i stedet for at du skal acceptere token for token, sådan som mange traditionelle autocomplete-værktøjer fungerer. Modellen er open-weight og open-data, hvilket Zed fremhæver som en bevidst modsætning til lukkede autocomplete-modeller fra konkurrenterne.

Edit Prediction er slået til som standard og kræver ingen ekstra opsætning for at komme i gang med Zeds hostede version. Vil du selv styre hvilken model der driver forudsigelserne, eller køre dem lokalt via et selvhostet setup, konfigureres det separat fra de øvrige AI-funktioner under edit_predictions i indstillingerne:

{
  "features": {
    "edit_prediction_provider": "zed"
  },
  "edit_predictions": {
    "mode": "eager"
  }
}

På det gratis Personal-plan får du 2.000 accepterede edit predictions om måneden med Zeds hostede Zeta-model. Bruger du din egen API-nøgle eller eksterne agenter i stedet, er brugen ubegrænset, fordi omkostningen så ligger hos dig og din udbyder i stedet for hos Zed.

Trin 5: Konfigurer BYOK med Claude, GPT eller Gemini

Bring Your Own Key (BYOK) er den mest fleksible måde at bruge Zeds AI-funktioner på, fordi du betaler direkte til modeludbyderen frem for gennem Zeds abonnement. Den letteste vej er at åbne Settings → AI → LLM Providers, hvor du kan indtaste din nøgle direkte, den gemmes derefter i systemets nøglering (Keychain på macOS, Credential Manager på Windows), ikke i selve settings.json-filen.

Alternativt kan Zed læse nøglerne direkte fra miljøvariabler. Det er praktisk, hvis du allerede har nøglerne sat op til andre værktøjer, som Claude Code eller Codex CLI:

UdbyderMiljøvariabel
Anthropic (Claude)ANTHROPIC_API_KEY
OpenAI (GPT)OPENAI_API_KEY
Google AI (Gemini)GEMINI_API_KEY
MistralMISTRAL_API_KEY
DeepSeekDEEPSEEK_API_KEY
xAI (Grok)XAI_API_KEY
OpenRouterOPENROUTER_API_KEY
Ollama (lokal)OLLAMA_API_KEY

Vigtigt: en ikke-tom miljøvariabel har altid forrang over en nøgle gemt i nøgleringen. Har du problemer med at skifte nøgle senere, er det som regel her fejlen ligger, mere om det i fejlfindingsafsnittet. Vil du finjustere en model med et brugerdefineret navn, kontekstvindue eller “thinking”-tilstand, kan du tilføje det direkte i settings.json:

{
  "language_models": {
    "anthropic": {
      "available_models": [
        {
          "name": "claude-sonnet-4-latest",
          "display_name": "claude-sonnet-4-thinking",
          "max_tokens": 200000,
          "mode": {
            "type": "thinking",
            "budget_tokens": 4096
          }
        }
      ]
    }
  }
}

Har du allerede et Claude Pro/Max-, ChatGPT Plus/Pro- eller GitHub Copilot-abonnement, behøver du ikke en separat API-nøgle. Zed understøtter også “Use an Existing Subscription”, hvor editoren autentificerer direkte mod din eksisterende aftale i stedet for at fakturere per token.

Trin 6: Installer Ollama og kør en lokal model uden cloud

Skal koden aldrig forlade din maskine, af GDPR-hensyn, kundekontrakter eller ren og skær vane, er lokal AI vejen frem. Zed understøtter Ollama, LM Studio og llama.cpp som lokale motorer. Ollama er det simpleste udgangspunkt. Hent det fra ollama.com, og pull derefter en model, for eksempel Mistral eller en DeepSeek Coder-variant:

ollama pull mistral
ollama serve

På macOS starter serveren automatisk, når du åbner Ollama.app, på Linux eller fra en shell kører du ollama serve manuelt. Så snart serveren kører, dukker de hentede modeller op i Zeds modelvælger uden yderligere opsætning. Vil du finjustere kontekstlængde eller vise en model, Zed ikke selv opdager, tilføjer du den eksplicit:

{
  "language_models": {
    "ollama": {
      "api_url": "http://localhost:11434",
      "available_models": [
        {
          "name": "mistral",
          "display_name": "Mistral (lokal)",
          "max_tokens": 32768
        }
      ]
    }
  }
}

Lokale modeller er typisk langsommere og svagere til komplekse refaktoreringer end Claude Opus eller GPT-5.4, men for simple opgaver, dokumentation, eller kode i kritiske brancher hvor data slet ikke må ud af huset, er det en reel mulighed. Kombinér gerne en lokal model til Edit Prediction med en cloud-model til Agent Panel, det bedste fra begge verdener.

Trin 7: Brug Agent Panel til at læse, skrive og rette kode

Agent Panel er hjertet i Zeds “agentic editing”. Åbn det med kommandopaletten (“agent: new thread”), eller via ikonet i sidepanelet. Skriv en opgave i almindeligt sprog, for eksempel “tilføj input-validering til registrerings-endpointet og skriv tre tests for edge cases”, og agenten begynder selv at søge gennem projektet, læse relevante filer, foreslå ændringer og køre kommandoer i terminalen, hvis den har lov til det.

Det, der adskiller Zeds agent fra en simpel chatbot, er at ændringerne vises som en redigerbar, samlet diff, du kan gennemgå linje for linje, før du accepterer eller afviser dem. Du kan endda følge agenten live, mens den navigerer koden, takket være den samme multiplayer-infrastruktur, Zed bruger til menneskelig samarbejde i realtid.

Adgangen til værktøjer (filsystem, terminal, websøgning, MCP-servere) styres granulært under Agent Profiles og Tool Permissions. Arbejder du med kildekode, du ikke ønsker agenten skal have fri adgang til at ændre, kan du låse specifikke mapper eller kræve manuel godkendelse, før agenten kører terminal-kommandoer. Det er en vigtig knap at kende, hvis du arbejder med produktionsnær kode eller følsomme kundedata.

Du kan også koble eksterne agenter direkte ind i Agent Panel via Agent Client Protocol (ACP), som er Zeds åbne protokol til at lade tredjepartsagenter fungere som førsteklasses borgere i grænsefladen. Det betyder, at Claude Agent, Codex eller OpenCode kan navigere din kodebase med samme redigerbare diff-visning og samme værktøjsadgang, som Zeds eget agent, i stedet for blot at være en chatboks i et sidepanel. Vil du udvide agentens viden yderligere, kan du koble Model Context Protocol-servere til, på samme måde som beskrevet i vores MCP-serveropsætning.

Trin 8: Aktivér Parallel Agents til samtidige opgaver

Parallel Agents er en af de funktioner, der reelt udnytter Zeds hastighedsfundament. I stedet for at køre én agent-tråd ad gangen, kan du åbne flere tråde samtidigt fra Threads Sidebar, hver med sin egen agent, sit eget kontekstvindue og sin egen samtalehistorik. En tråd kan for eksempel arbejde på et backend-refaktoreringsjob med Claude, mens en anden retter en frontend-fejl med en anden model, i samme vindue, uden at de blander sig i hinandens kontekst.

Åbn sidepanelet med Cmd+Alt+J / Ctrl+Alt+J, og opret en ny tråd i en specifik projektgruppe ved at holde musen over projektets header og klikke på plus-ikonet. Kør flere tråde i samme Git-worktree, eller isolér dem i separate worktrees, hvis du vil undgå, at to agenter redigerer den samme fil samtidigt, en indstilling der findes under Worktree Isolation i trådindstillingerne.

Til hurtig navigation mellem tråde, uden at åbne sidepanelet, bruger du Ctrl+Tab til at cykle fremad gennem de seneste tråde, og Shift holdt nede for at gå baglæns. Det virker fra både Agent Panel og Threads Sidebar, og det bliver hurtigt en vane, når du først har tre-fire tråde kørende parallelt.

Trin 9: Sæt Terminal Threads op med et eksternt CLI-værktøj

Terminal Threads lader dig køre eksterne CLI- eller TUI-agenter, som Claude Code eller Codex CLI, direkte som en tråd i sidepanelet, med samme tastaturnavigation som Zeds egne agent-tråde. CLI-værktøjet ejer selv sin autentificering og konfiguration, Zed leverer blot terminalvinduet og trådstrukturen omkring det.

Opret en Terminal Thread fra Threads Sidebar med “new terminal thread”, og vælg det CLI-værktøj, du allerede har installeret og autentificeret på din maskine. Terminal Threads dukker op side om side med almindelige agent-tråde, markeret med et terminal-ikon, så du hurtigt kan skifte mellem for eksempel Zeds egen agent og en ekstern Claude Code-session uden at forlade Agent Panel.

Funktionen er praktisk, hvis dit team allerede har standardiseret på et bestemt CLI-værktøj, men gerne vil have det integreret i en hurtigere editor. Bemærk, at import af eksisterende trådhistorik fra eksterne agenter afhænger af, hvilket værktøj du bruger, nogle CLI-agenter understøttes endnu ikke fuldt ud til import.

Trin 10: Brug Inline Assistant til hurtige rettelser

Ikke alle opgaver kræver en fuld agent-tråd. Til mindre, afgrænsede ændringer, omdøb en variabel konsekvent, oversæt en kommentar, forenkl et udtryk, markerer du koden og åbner Inline Assistant med kommandopaletten. Beskriv ændringen i almindeligt sprog, og få forslaget vist direkte i editoren som en inline-diff, uden at skulle skifte til et separat panel.

Inline Assistant bruger samme model-konfiguration som resten af Zeds AI-funktioner, men kan sættes til en anden, hurtigere model end den, du bruger til tunge agent-opgaver:

{
  "agent": {
    "inline_assistant_model": {
      "provider": "anthropic",
      "model": "claude-sonnet-4-latest"
    }
  }
}

Til daglig brug er det ofte hurtigere end at skrive en fuld prompt til Agent Panel, fordi du forbliver i samme fil og ser resultatet med det samme.

Trin 11: Byg et komplet mini-projekt med Zed AI-agenter fra start til slut

Nu samler vi trådene. Vi bygger en lille Node.js REST-API med en enkelt route, tests og en README, udelukkende ved hjælp af Zeds AI-funktioner, for at vise, hvordan trinene ovenfor spiller sammen i praksis.

  1. Opret en ny mappe, initialisér et Git-repo, og åbn den i Zed med zed .
  2. Åbn Agent Panel og skriv: “Opret et minimalt Express-API med én GET-route /status, der returnerer JSON med uptime og version. Tilføj package.json og en simpel test med Vitest.”
  3. Gennemgå den foreslåede diff. Accepter filoprettelsen, men bed agenten justere navngivningen, hvis den ikke matcher din stil, direkte i samtalen
  4. Åbn en ny parallel tråd (Trin 8), og bed en anden model skrive en README.md, mens den første tråd stadig arbejder på testene
  5. Brug Zeta (Trin 4) til at acceptere små autocomplete-forslag, mens du selv finpudser koden manuelt
  6. Marker package.json, åbn Inline Assistant (Trin 10), og bed den tilføje et start-script
  7. Kør testene i den indbyggede terminal, og lad agenten rette eventuelle fejl, den selv ser i outputtet

Et typisk output efter trin 2 kan se sådan ud, når agenten har oprettet filen:

// index.js
import express from "express";
const app = express();

app.get("/status", (req, res) => {
  res.json({
    uptime: process.uptime(),
    version: "1.0.0"
  });
});

app.listen(3000, () => console.log("Server kører på port 3000"));

Hele forløbet, fra tom mappe til testet API med README, tager typisk 10-15 minutter, når du kombinerer parallelle tråde med Inline Assistant til finpudsning. Det er præcis den slags workflow, Zeds hastighedsfokus er bygget til, du venter aldrig på, at grænsefladen følger med agenten.

Zed vs Cursor vs GitHub Copilot: hvad er egentlig forskellen?

De tre værktøjer løser overlappende problemer, men med forskellige prioriteter. Cursor er bygget som en VS Code-fork med agent-funktioner tæt integreret i en velkendt grænseflade. GitHub Copilot er mest udbredt, fordi det følger med i selve GitHub-økosystemet og kan bruges direkte i VS Code, Visual Studio, JetBrains-IDE’er og faktisk også i Zed som ekstern agent. Zed satser på hastighed og modelfrihed frem for et stort udvalg af indbyggede funktioner.

EgenskabZedCursorGitHub Copilot
FundamentRust, egen GPUI-rendererVS Code-fork (Electron)Udvidelse til VS Code, JetBrains m.fl.
Gratis plan$0, 2.000 edit predictions/md.Hobby: begrænsede agent-forespørgsler$0, 2.000 completions/md.
Laveste betalte planPro: $10/md.Individual: fra $20/md.Pro: $10/bruger/md.
Team-planBusiness: $30/sæde/md.Teams: $40/bruger/md.Pro+: $39/bruger/md.
BYOK (egne API-nøgler)Ja, 10+ udbydereBegrænset, primært på Business/EnterpriseNej, kun Copilot-abonnement
Lokale modellerJa, Ollama/LM Studio/llama.cppNejNej
Parallelle agent-trådeJa, indbygget (Parallel Agents)Delvist, via Cloud AgentsDelvist, via Copilot cloud agent

Priserne ovenfor er hentet direkte fra Cursors og GitHub Copilots officielle prissider i august 2026, og fra Zeds egen prisside. Omregnet til danske kroner til en kurs på cirka 7 kr. per dollar svarer Zed Pro til omkring 70 kr. om måneden, mens Zed Business lander på cirka 210 kr. per sæde. Det gør Zed til den billigste af de tre på både individ- og teamniveau, men husk, at Cursor og Copilot til gengæld har flere år mere markedsmodning og et større udvalg af færdigbyggede integrationer.

Hvis du allerede har læst vores gennemgang af MCP-serveropsætning til fire AI-assistenter, vil du genkende, at Zed understøtter MCP på samme måde som Claude Code og Cursor, hvilket betyder, at du kan koble de samme eksterne værktøjsservere på uanset hvilken editor du ender med at vælge.

Et argument, der ofte overses i sammenligninger, er ren renderingsydelse. Fordi Zed er skrevet fra bunden i Rust med en GPU-accelereret motor, mærker du forskellen tydeligst i store monorepos eller når en agent redigerer dusinvis af filer på én gang, scroll og filskift forbliver flydende, mens Electron-baserede editorer som VS Code og Cursor typisk oplever en mærkbar forsinkelse under samme belastning. Det er ikke afgørende for de fleste opgaver, men hvis dit team arbejder i store kodebaser med hyppige agent-kørsler, er det en reel faktor at veje ind i valget.

Databeskyttelse og GDPR: hvad sender Zed egentlig til AI-modellerne?

For danske og nordiske teams under GDPR er spørgsmålet om, hvad der forlader din maskine, ikke akademisk. Zed har en indbygget gennemsigtighedsfunktion, der viser dig præcis, hvilken kontekst (filer, kode, tidligere beskeder) der bliver sendt til modellen, før forespørgslen sendes af sted, og du kan redigere konteksten manuelt, hvis den indeholder noget følsomt.

Vil du undgå cloud-transmission helt, er kombinationen af lokale modeller (Trin 6) og deaktiverede AI-funktioner den sikreste vej. Kører du derimod med cloud-modeller, er det værd at huske, at BYOK-opsætningen sender data direkte til den udbyder, du selv har valgt, Anthropic, OpenAI eller Google, med de databehandleraftaler den udbyder tilbyder, mens Zeds hostede modeller sender data gennem Zeds egen infrastruktur som mellemled. For teams under NIS2 eller med kontraktuelle krav om databehandleraftaler bør I altid verificere den konkrete DPA hos den model-udbyder, I vælger, uanset hvilken editor I bruger.

Zed Business tilføjer et administrativt lag oven på dette: organisationsdækkede AI-modelpolitikker, mulighed for at slå Edit Prediction fra for hele organisationen, og lås på databelingspolitikker, så enkelte medlemmer ikke kan omgå dem. SSO via SAML og SCIM er annonceret, men var ifølge Zeds egen dokumentation endnu ikke tilgængeligt i skrivende stund, tjek den officielle prisside for opdateret status, før I lægger jeres onboarding-plan.

Hvornår giver det mening for et nordisk team at skifte til Zed?

Ikke alle teams bør springe på det nyeste værktøj, bare fordi det er hurtigere. Zed giver mest mening, hvis I allerede har API-nøgler eller kontrakter med Anthropic, OpenAI eller Google, og gerne vil undgå at betale for et ekstra AI-abonnement oven i dem, I allerede har. Det samme gælder, hvis I arbejder i store, ældre kodebaser, hvor en Electron-baseret editor begynder at mærkes langsom, eller hvis compliance-krav betyder, at I skal kunne dokumentere præcis, hvilken kontekst der sendes til en given model.

Omvendt er Zed endnu ikke det oplagte valg, hvis teamet er dybt afhængigt af et bredt udvidelsesøkosystem, VS Codes marketplace er langt større end Zeds, eller hvis I har brug for enterprise-funktioner som SSO via SAML, der ifølge Zeds egen dokumentation stadig er under udvikling. En pragmatisk tilgang er at lade et par udviklere køre Zed side om side med jeres nuværende opsætning i et par uger, og sammenligne oplevet hastighed og AI-kvalitet på jeres egen kodebase, frem for at stole blindt på benchmarks fra andre projekter.

5 almindelige faldgruber, når du sætter Zed AI op

De fleste problemer nye Zed-brugere støder på, handler ikke om selve editoren, men om forventninger overført fra andre værktøjer. Her er de fem, vi ser hyppigst, når udviklere skifter fra Cursor, VS Code eller JetBrains til Zed for første gang.

  1. At forveksle Edit Prediction-konfiguration med Agent-konfiguration. De to features styres af forskellige indstillingsblokke (edit_predictions vs. language_models/agent). Sætter du kun den ene op, virker autocomplete, men agenten mangler stadig en model, eller omvendt.
  2. At glemme, at miljøvariabler overtrumfer nøgleringen. Har du testet med en midlertidig ANTHROPIC_API_KEY i terminalen, og senere gemt en anden nøgle i Zeds indstillinger, bruger Zed stadig miljøvariablen, indtil du unsetter den og genstarter editoren.
  3. At give agenten fri adgang til terminalen uden at læse profilindstillingerne. Standardprofilerne varierer i, hvor meget agenten må gøre uden godkendelse. Kør aldrig en agent med fuld terminal-adgang på et repo, du ikke har committet den seneste tilstand af.
  4. At antage, at lokale modeller matcher cloud-modellers kvalitet. En 7B-13B lokal model via Ollama er fin til simple opgaver, men vil ofte fejle på flertrins-refaktoreringer, som Claude eller GPT klarer uden problemer. Match modelvalget til opgavens kompleksitet.
  5. At køre for mange parallelle agent-tråde på samme worktree. Uden Worktree Isolation slået til kan to agenter redigere den samme fil samtidigt og overskrive hinandens ændringer. Isolér tråde, der arbejder på overlappende dele af kodebasen.

Fejlfinding: 8 almindelige problemer og løsninger

Løb du ind i noget, der ikke virker som forventet undervejs i trinene ovenfor? Tjek tabellen herunder, før du begynder at fejlsøge fra bunden, langt de fleste opstartsproblemer med Zed AI falder inden for en af disse otte kategorier.

ProblemSandsynlig årsagLøsning
Zed starter ikke, eller skærmen forbliver sort på LinuxManglende eller for gammel Vulkan-driverInstallér/opdatér Vulkan 1.3-drivere, eller kør i software-rendering-tilstand midlertidigt
API-nøgle accepteres ikke i indstillingerneEn modstridende miljøvariabel er satKør echo $ANTHROPIC_API_KEY (eller relevant variabel) i terminalen, unset den, genstart Zed
Agent Panel viser “no model configured”Ingen udbyder er valgt under LLM ProvidersÅbn Settings → AI → LLM Providers, og vælg en aktiv udbyder eksplicit
Ollama-modeller dukker ikke op i modelvælgerenOllama-serveren kører ikke, eller lytter på forkert portKør ollama serve manuelt, og tjek at api_url matcher (standard http://localhost:11434)
Edit predictions virker slet ikkeFunktionen er slået fra, eller kvoten på 2.000/md. er brugtTjek edit_prediction_provider i settings, og se forbrug under Account & Billing
Terminal Thread starter ikke det eksterne CLI-værktøjVærktøjet er ikke installeret eller ikke i PATHBekræft installationen i en almindelig terminal først, før du opretter tråden i Zed
Parallelle agenter overskriver hinandens filerWorktree Isolation er slået fraAktivér separate Git-worktrees per tråd i trådindstillingerne
Høj CPU-belastning ved store projekterTree-sitter-indeksering af meget store monoreposEkskludér build- og node_modules-mapper via file_scan_exclusions i settings

Avancerede tips til Zed AI-agenter

  • Brug forskellige modeller til forskellige formål: en billig, hurtig model til Edit Prediction og Inline Assistant, og en dyrere frontier-model kun til Agent Panel-opgaver, der kræver dyb resonnering
  • Sæt et brugsloft (“spending cap”) på dit Pro-abonnement, hvis du kører mange parallelle tråde, så et enkelt uheld ikke sender regningen skyhøjt
  • Brug Skills og Instructions (findes under AI-indstillingerne) til at give agenten faste projektspecifikke retningslinjer, kodestandard, testkrav, forbudte mønstre, i stedet for at gentage dem i hver prompt
  • Koble MCP-servere til agenten, hvis dit team allerede har opsat dem til Claude Code eller andre AI-assistenter, protokollen er den samme på tværs af værktøjerne
  • Brug Thread History til at genfinde og genstarte gamle sessioner, i stedet for at starte forfra hver gang du vender tilbage til en opgave

Priser i 2026: hvad koster Zed reelt?

PlanPrisIndhold
Personal$0 for altid2.000 accepterede edit predictions/md., ubegrænset med egne API-nøgler eller eksterne agenter
Pro$10/md. (cirka 70 kr.)Ubegrænsede edit predictions, $5 i inkluderede tokens, herefter API-listepris +10%
Business$30/sæde/md. (cirka 210 kr.)Organisationsstyring, databelingspolitikker, samlet fakturering, alt fra Pro på sædeniveau

Zed tilbyder desuden en to-ugers gratis prøveperiode af Pro-planen med $20 i inkluderede token-credits, dog uden adgang til de dyreste modeller som Claude Opus og “GPT Pro”-varianter under selve prøveperioden. Ønsker du slet ikke at betale for Zed, men foretrækker at bruge dine egne nøgler, er det gratis Personal-plan fuldt ud tilstrækkelig, den eneste begrænsning ligger på antallet af gratis edit predictions, ikke på selve agent-funktionaliteten.

Ofte stillede spørgsmål om Zed Editor og AI-agenter

Er Zed gratis at bruge?

Ja. Personal-planen er gratis for altid og inkluderer 2.000 accepterede edit predictions om måneden. Bruger du dine egne API-nøgler eller eksterne agenter i stedet for Zeds hostede modeller, er der ingen brugsbegrænsning fra Zeds side, selve editoren koster intet uanset hvilken AI-opsætning du vælger.

Kan jeg bruge Zed uden internetforbindelse?

Som ren kodeeditor, ja. Med AI-funktioner kræver det, at du har sat en lokal model op via Ollama, LM Studio eller llama.cpp (Trin 6), ellers kræver Zeta og Agent Panel en forbindelse til enten Zeds hostede modeller eller den cloud-udbyder, du selv har konfigureret.

Er Zed bedre end Cursor?

Det afhænger af, hvad du prioriterer. Zed vinder på rå ydelse og modelfrihed, med understøttelse af over ti udbydere inklusive lokale modeller. Cursor har et mere modent økosystem af agent-funktioner og et større bibliotek af integrationer, fordi det er bygget oven på VS Codes udvidelsesplatform. Prøv begge på et rigtigt projekt, før du vælger, prisforskellen er lille nok til, at det er umagen værd.

Kan jeg bruge GitHub Copilot inde i Zed?

Ja. GitHub Copilot lister officielt Zed som en understøttet platform ved siden af VS Code, Visual Studio, JetBrains-IDE’er og Neovim, så har du allerede et Copilot-abonnement, kan du autentificere det direkte i Zed under Use an Existing Subscription.

Hvad er forskellen på Zed Agent, External Agents og Terminal Threads?

Zed Agent er editorens egen indbyggede agent, styret af Zeds indstillinger, profiler og MCP-opsætning. External Agents er tredjepartsagenter som Claude Agent eller Codex, tilsluttet via Agent Client Protocol (ACP), men vist i samme grænseflade. Terminal Threads kører et CLI/TUI-værktøj direkte i en terminal-baseret tråd, hvor selve værktøjet ejer autentificering og konfiguration.

Er mine data sikre, når jeg bruger Zeds AI-funktioner?

Zed viser dig, hvilken kontekst der sendes til modellen, før forespørgslen afsendes, og du kan redigere den. Bruger du BYOK, går data direkte til den valgte udbyder under deres databehandleraftale. Bruger du Zeds hostede modeller, går data gennem Zeds infrastruktur som mellemled. For maksimal kontrol, brug lokale modeller via Ollama, hvor intet forlader din maskine.

Virker Zed på ældre Mac- eller Linux-maskiner?

Zed understøtter macOS tilbage til Monterey (12.x) fuldt ud, og Big Sur/Catalina delvist, uden skærmdeling. På Linux kræves en Vulkan 1.3-driver, hvilket kan være en udfordring på ældre integrerede grafikkort eller i visse virtuelle maskiner uden GPU-passthrough.

Skal jeg vælge Zed Pro eller BYOK med min egen nøgle?

Er dit forbrug lavt til moderat, er Zed Pro med de inkluderede $5 i tokens ofte det enkleste. Bruger du meget, eller vil du have fuld kontrol over, hvilken model der bruges til hvad, giver BYOK dig direkte adgang til udbyderens listepris uden Zeds tillæg på 10%, forudsat at du selv har styr på fakturering og kvoter hos udbyderen.