# Så kör du Claude Code och Codex över natten via /goal år 2026: 14 timmars autonomt läge > Kommandot /goal i Claude Code 2.1.139 och Codex CLI låter en AI-agent arbeta självständigt i timmar. Jag förklarar konfigurationen, verkliga exempel och hur många token det kostar. Source: https://ailoot.ai/blog/sv/goal-mode-claude-code-codex/ Canonical: https://ailoot.ai/blog/sv/goal-mode-claude-code-codex/ Language: sv Publisher: Ailoot (https://ailoot.ai/) Translation: guide-103 Revision: sha256-7bcc193e0f450729c0777e7891c879d616bf9b40f54af803b987caff86ad6bea
Det viktigaste Kommandot `/goal` dök upp i Claude Code 2.1.139 (11 maj 2026) och Codex CLI 0.128.0 (30 april 2026, stabilt sedan 21 maj). Du definierar kriteriet för när arbetet är klart en gång, och agenten går själv igenom planering, åtgärder och verifiering tills kriteriet är uppfyllt eller tokenen tar slut. OpenAI visade offentligt en körning på 25 timmar med 13 miljoner token. Det här passar för migreringar, benchmarktester och refaktoreringar med mätbara kriterier. Det passar inte för UI-uppgifter, produktionsdatabaser eller vaga önskemål som ”gör det bättre”.
Information om hur du arbetar med Ailoot finns i [dokumentationen](https://ailoot.ai/docs/). ## Vad är `/goal` och varför dök det upp 2026?
Det viktigaste Före `/goal` krävde varje agenttur ett manuellt ”fortsätt”. Den öppnade en fil, läste den, skrev något, stannade och väntade. Med kommandot `/goal` anger du ett kriterium för när arbetet är klart en gång. Agenten avgör själv när uppgiften är slutförd och lämnar inte tillbaka kontrollen förrän den är färdig.
Scenariot vi alla levde med före april 2026: Jag ger Claude en uppgift: ”migrera projektet från Pydantic v1 till v2”. Den börjar, stannar efter 30 sekunder, jag tittar på vad den gjorde och skriver ”fortsätt”. Den tar nästa steg, stannar och jag skriver ”fortsätt” igen. Vid en stor migrering innebär det 200–300 manuella ”fortsätt”, och i praktiken passar jag agenten i stället för att skriva annan kod parallellt. OpenAI:s analys var att problemet inte var modellens ”dumhet”, utan loopens arkitektur. Modellen visste inte när den skulle stanna, så den bromsade vid varje tur. Ge den ett kriterium för när arbetet är klart, så avgör den själv. Så uppstod `/goal` – en mekanism inbyggd i körmiljön, inte i modellen. Uttalandet gjordes på konferensen Code with Claude i London den 19–20 maj 2026. Det beskriver vad som faktiskt hände under månaden efter att `/goal` lanserades i båda verktygen. ## Hur konfigurerar du Goal-läget i Claude Code?
Det viktigaste Claude Code 2.1.139 släpptes den 11 maj 2026 med kommandot `/goal`. En liten modell (Haiku som standard) kontrollerar kriteriet efter varje tur. Om kriteriet inte är uppfyllt tar Claude en tur till. Kriteriet kan vara upp till 4,000 tecken långt, och det finns ett mål per session.
Ett minimalt exempel från Anthropics officiella dokumentation: ```bash claude -p "/goal CHANGELOG.md har en post för varje PR som slagits samman den här veckan" ``` Det här kommandot startar agenten i bakgrunden med ett mål. Claude hittar PR:erna, kontrollerar dem mot CHANGELOG.md, lägger till eventuella saknade rader och stannar när kriteriet är uppfyllt. I interaktivt läge skriver du bara `/goal` följt av villkoret: ``` /goal alla pytest-tester godkänns och mypy strict rapporterar noll fel ``` Vad Claude gör sedan: - Efter varje tur får en separat snabb modell (Haiku som standard) det aktuella villkoret och konversationshistoriken - Modellen svarar ”ja” eller ”nej” med en kort motivering - Om svaret är ”nej” tar Claude automatiskt en ny tur utan att lämna tillbaka kontrollen till dig - Om svaret är ”ja” rensas målet och kontrollen lämnas tillbaka till dig

Efter varje tur kontrollerar en liten, snabb modell om villkoret har uppfyllts. Om det inte har uppfyllts startar Claude en ny tur utan att lämna tillbaka kontrollen till dig.

— Officiell dokumentation för Claude Code, https://code.claude.com/docs/en/goal
Hårda begränsningar som ingen berättar om förrän du stöter på dem: - `/goal` fungerar bara i arbetskataloger där du har godkänt förtroendedialogen. Om du är på en ny dator och Claude ännu inte har kommit ihåg katalogen misslyckas kommandot - I företagsmiljöer med `disableAllHooks` eller `allowManagedHooksOnly` är kommandot inte tillgängligt - Villkoret kan vara upp till 4,000 tecken långt - Endast ett mål kan vara aktivt per session. Ett nytt `/goal` återställer det gamla - Med `--resume` bevaras villkoret, men räknarna för turer, tid och token återställs Kommandon för styrning: - `/goal` utan argument – visa aktuell status - `/goal clear` (eller `stop`, `off`, `reset`, `none`, `cancel`) – rensa målet Enligt Anthropic är utvärderarens kostnad ”vanligtvis försumbar jämfört med kostnaden för huvudturen”. Haiku utvärderar kriteriet och konversationstexten och anropar inga verktyg, så kontrollen är billig. Det dyra är huvudmodellens turer. ## Hur konfigurerar du `/goal` i Codex CLI?
Det viktigaste Codex CLI 0.128.0 lade till `/goal` den 30 april 2026 som en experimentell funktion. Den 21 maj blev läget stabilt i version 26.519 / npm 0.133.0. Det fungerar med två promptmallar – `continuation.md` (”fortsätt”) och `budget_limit.md` (”stopp”). Målet är knutet till tråden och finns kvar efter omstarter.
Kommandot ser likadant ut som i Claude: ```bash codex > /goal alla vitest-tester godkänns och det inte finns några eslint-fel ``` Codex erbjuder fler styrkommandon: | Kommando | Vad det gör | |-----------------|---------------------------| | `/goal condition` | ange ett mål | | `/goal` | visa status | | `/goal pause` | pausa | | `/goal resume` | återuppta | | `/goal edit` | ändra villkoret (med GA) | | `/goal clear` | rensa målet | Den största skillnaden mot Claude är att Codex själv kontrollerar om arbetet är ”klart”, i stället för att en separat modell gör det. Efter varje tur infogar Codex automatiskt mallen `continuation.md` från kodförrådet `openai/codex` i kontexten. En ordagrann översättning: > ”Fortsätt arbeta mot det aktiva trådmålet. Upprepa inte arbete som redan är gjort. Välj nästa konkreta åtgärd mot målet. Markera målet som uppnått först när en granskning visar att målet faktiskt har uppnåtts och inget nödvändigt arbete återstår.” När tokenen närmar sig gränsen infogas en andra mall – `budget_limit.md`: > ”Målet har nått sin tokengräns. Påbörja inget omfattande nytt arbete. Avsluta den här turen så snart som möjligt: sammanfatta användbara framsteg, identifiera återstående arbete och hinder och ge användaren ett tydligt nästa steg.” Logiken är densamma: ”ljug inte om vad du har gjort”. Fortsättningen kräver att arbetet fortsätter endast om målet faktiskt inte har uppnåtts. Budget_limit kräver att arbetet stoppas, men att det som återstår beskrivs ärligt. Till skillnad från Claude knyter Codex målet till tråden, inte sessionen. Du kan till exempel stänga terminalen och öppna den igen på morgonen, så återupptar `/goal resume` samma mål med samma fakta i minnet. Det är användbart för körningar som du delar upp i pass efter ditt eget schema. ## Hur skiljer sig `/goal` i Claude Code från `/goal` i Codex?
Det viktigaste Claude skiljer på den som skriver och den som bedömer: huvudmodellen skriver kod och en separat liten modell bedömer. Codex är en agent som kontrollerar sitt eget arbete – den påminner sig själv: ”ljug inte om vad du har gjort”. Arkitekturerna skiljer sig åt, men risken för att fastna i en loop är densamma.
Det här är den vanligaste luckan i jämförelser, så låt oss titta närmare på den. | Aspekt | Claude Code `/goal` | Codex `/goal` | |----|----|----| | Släpp | v2.1.139, 11 maj 2026 | v0.128.0, 30 april 2026 (experimentellt) → v0.133.0 / 26.519, 21 maj 2026 (stabilt) | | Målets omfattning | Session | Tråd (finns kvar efter omstarter) | | Styrning | `set`, `clear` (+ alias) | `set`, `view`, `pause`, `resume`, `edit`, `clear` | | Vem kontrollerar om det är ”klart” | Separat modell (Haiku som standard) | Samma agent, via en infogad prompt | | Utvärderarens åtkomst till filer | Nej; den bedömer bara utifrån konversationstexten | Ja; den kan granska filer, tester och loggar | | Budget | I villkorstexten: ”eller stoppa efter 20 turer” | Inbyggd tokengräns + automatisk infogning av `budget_limit.md` | | Hård utgiftsgräns | Ingen; endast abonnemangsgränsen | Ingen; endast abonnemangsgränsen | | Villkorets längd | Upp till 4,000 tecken | Inte specificerat | | Var det fungerar | Interaktivt läge, `-p`, datorapp, Remote Control | App, IDE-tillägg, CLI, ACP-klienter | Den konceptuella skillnaden är att Claude behandlar loopen som ett kvalitetsåtagande (en extern utvärderare), medan Codex behandlar den som en körmekanism (agenten hanterar sig själv). I praktiken innebär det här: om du vill att kriteriet för när arbetet är klart ska bedömas opartiskt väljer du Claude. Om du vill att agenten ska kunna kontrollera filer och loggar under utvärderingen väljer du Codex. Läs mer om själva verktygen i [guiden Codex jämfört med Claude Code](https://ailoot.ai/blog/sv/codex-vs-claude-code-choice/). ## Verkligt exempel: migrering från Pydantic v1 till v2 på 31 timmar
Det viktigaste Codex `/goal` slutförde migreringen av 14,000 rader i en intern tjänst från Pydantic v1 till v2 på 31 timmars faktisk tid, fördelat på fyra sessioner. Kostnaden var cirka $44 med gpt-5.3-codex.
Uppgiften formulerades så här: ”migrera från Pydantic v1 till v2, alla pytest-tester måste godkännas och mypy strict måste rapportera noll fel.” Vad som hände: - Session 1 (8 timmar) – Codex analyserade importerna, skrev om `BaseModel`-deklarationerna och satte upp mypy - Session 2 (10 timmar) – skrev om validatorer och fick cirka 200 tester att fallera - Session 3 (7 timmar) – fixade testerna och hittade cirkulära beroenden - Session 4 (6 timmar) – löste de återstående mypy-felen och regressionerna Tokenkostnad: > ”Total tid på klockan: cirka 31 timmar fördelat på fyra sessioner. Den totala tokenskostnaden för Codex till gpt-5.3-codex-priser var cirka \$44.” Kostnaden domineras av utgående token från gpt-5.3-codex, med en taxa på \$14 per miljon. Det innebär att 31 timmars autonomt arbete kostar ungefär lika mycket som veckor av ett ChatGPT Plus-abonnemang. Vad agenten inte gjorde på egen hand: - Den skrev inte någon migreringsdokumentation för teamet (Codex förstod inte att det ingick i ”migreringen”) - Den uppdaterade inte konfigurationsfiler för publicering med den nya versionen av Pydantic - Den missade en produktionsregression, som upptäcktes först en dag senare Med andra ord gjorde `/goal` 95% av arbetet. De återstående 5% måste fortfarande göras för hand. Det är normalt för den nuvarande generationen och ingen anledning att avstå från att använda det. Den allmänna regeln: ## 14 timmar med en macOS-drivrutin över natten ## Uppgifter som passar för långa nattkörningar
Det viktigaste Drivrutiner passar dåligt för interaktivt arbete men väl för långkörande loopar.
De typer av uppgifter där metoden ger störst fördelar: - Lågnivåarbete där en iteration och kontroll tar minuter (kompilering, testkörning) - Migreringar med tydliga formella kriterier (typer, tester, lint) - Benchmarktester och optimeringar med mätbara resultat - Dokumentation och ändringsloggar med tydlig struktur Claude `/goal` gör samma sak lika bra, men Codex väljs oftare för drivrutiner eftersom det kontrollerar filer och loggar själv i stället för att förlita sig på en extern bedömare. ## Hur mycket kostar det, och hur undviker du att bränna igenom token över natten?
Det viktigaste `/goal` har ingen hård övre utgiftsgräns – bara gränserna i ditt abonnemang. En faktisk timme med Codex kostar cirka $1.50–$3 med gpt-5.3-codex. Claude kostar mer att köra och mindre att utvärdera. Det enda skyddet är att skriva ”eller stoppa efter N turer” i själva villkoret.
Uppgifter från offentliga redogörelser: | Körning | Varaktighet | Token | Kostnad | |----|----|----|----| | Demo av OpenAI:s designverktyg | 25 timmar | 13M | (intern körning) | | Pydantic v1→v2 | 31 timmar, 4 sessioner | ~3.1M utgående | ~\$44 | | Röstintervjusystem | Totalt 6 timmar 44 minuter (41 minuters beräkning) | 6.8 miljoner inkommande, 94% cachade | \- | | Typsnittstest | 5 minuter | 188,832 | mindre än 5% av veckokvoten | Det viktigaste att förstå är att varken Claude Code eller Codex har en hård gräns av typen ”sluta spendera vid $N”. Det finns tre skydd: 1. **Abonnemangsgränser** – Pro, Max eller Enterprise. Med Anthropics Max-abonnemang ($100/månad) ryms en 14-timmarskörning över natten inom veckokvoten, med marginal 2. **Textgräns i villkoret** – skriv ”eller stoppa efter 20 turer” direkt i `/goal`. Claude-bedömaren läser det och avslutar målet 3. **Tokengräns i Codex** – inbyggd mekanism som infogar `budget_limit.md` när tokenen tar slut Vad som driver upp kostnaden över natten: - Ett vagt kriterium som ”gör det smidigare” – agenten slutar aldrig eftersom utvärderaren inte vet vad ”bättre” betyder - Åtkomst till externa API:er utan stubbar – varje nytt försök kostar token - Lång kontext – efter 6.7M token aktiveras kontextkomprimering och en del minne går förlorat Läs mer om att spara kostnader i guiderna [vart Claude Code-tokenen tar vägen](https://ailoot.ai/blog/sv/where-claude-code-tokens-go/) och [hur du undviker att bränna igenom dina gränser](https://ailoot.ai/blog/sv/claude-code-token-limits-saving/). ## När ska du INTE köra `/goal`: 5 situationer
Det viktigaste Vaga kriterier som ”få det att se snyggt ut”, ändringar på en rad, produktionsdatabaser med användardata, säkerhetskritiska ändringar och uppgifter med oklara externa beroenden. I alla fem situationerna kommer agenten antingen att fastna i en loop eller att bränna token i onödan.
OpenAI:s dokumentation säger uttryckligen vad du INTE ska göra: 1. **Ändringar på en rad** – att köra `/goal` för att byta namn på en variabel kostar mer än att göra det för hand 2. **Vaga mål** – ”förbättra prestandan”, ”gör koden renare”, ”gör det smidigare”. Utvärderaren saknar kriterier, så agenten snurrar vidare i all oändlighet 3. **Produktionsdatabaser med användardata** – agenten kan förstöra en migrering, och det kostar mer att återställa från en säkerhetskopia än vad du sparar 4. **Säkerhetsändringar** – autentisering, kryptering, betalningshantering. Här måste en person granska varje commit 5. **Externa API:er utan stubbar** – varje nätverksfel kostar token och ligger utanför din kontroll ## Vad ska du göra om agenten fastnar?
Det viktigaste Ett tecken på en loop är att agenten redigerar samma ställe i 3–4 turer och sedan återställer ändringarna. Avbryt den med Ctrl+C, kontrollera loggen och gör sedan kriteriet striktare eller begränsa uppgiften till en del. I Claude hjälper `/goal clear`; i Codex använder du `/goal pause` och redigerar villkoret.
Så upptäcker du snabbt en loop: - Agenten rör samma filer i 3+ turer och återställer dem sedan till föregående tillstånd - Samma fel dyker upp upprepade gånger i loggen, fel som agenten redan har reagerat på - Du tycker att villkoret är uppfyllt, men agenten säger ”inte uppfyllt” - Tokenanvändningen per tur ökar, men det sker inga kodframsteg Vad du gör härnäst: - I Claude Code: `/goal clear`, och gör sedan villkoret mer specifikt - I Codex: `/goal pause`, granska den aktuella tråden, redigera villkoret med `/goal edit` och kör sedan `/goal resume` - I båda: kontrollera att kriteriet faktiskt går att verifiera (ett kommando returnerar exit 0 eller ger en specifik utskrift) Ofta ligger orsaken till loopen i själva uppgiften, inte i agenten. Villkoret ”alla tester godkänns” förutsätter att testerna över huvud taget kan godkännas. Om det finns ett djupt arkitekturproblem i koden kommer agenten fortsätta att kretsa kring symptomet. ## Kriterier för när arbetet är ”klart”: uppgiftsdisciplin för `/goal`
Det viktigaste Ett bra kriterium är ett kommando som returnerar exit 0 eller ger en specifik utskrift. ”Alla tester godkändes” fungerar. ”Koden är renare” gör det inte. Det bästa är att kombinera en formell kontroll med ett mätbart mått – till exempel tester plus minsta täckningsgrad.
OpenAI uttrycker regeln tydligt i sitt officiella Codex Cookbook:

Ett mål anses inte vara uppfyllt bara för att modellen tycker det. Ett mål är uppfyllt först när resultatet har kontrollerats mot filer, tester, loggar, benchmarktester eller andra konkreta artefakter.

— OpenAI Codex Cookbook, Använda mål i Codex, https://developers.openai.com/cookbook/examples/codex/using_goals_in_codex
Kriteriemallar som faktiskt fungerar: | Kriterietyp | Så här formulerar du det | |----|----| | Tester | ”pytest tests/ returnerar exit 0 och täckningsgraden är minst 80%” | | Typer | ”mypy strict rapporterar noll fel i src/” | | Lint | ”eslint . returnerar exit 0 för alla ändrade filer” | | Bygge | ”npm run build slutförs utan fel och utan TypeScript-fel” | | Benchmark | ”k6 run perf test visar p95 under 200 ms” | | Diff | ”git diff visar endast ändringar i filerna X, Y, Z” | | Kombination | ”pytest är grönt OCH mypy strict rapporterar noll fel OCH ruff check godkänns” | Kombinationsraden använder tester, mypy och lint. Om ens en kontroll fortfarande visar fel avslutas inte målet. Utvärderaren har ingen möjlighet att fuska. Antimönster: - ”Koden är bättre” - ”Användbarheten har förbättrats” - ”Prestandan har förbättrats” - ”Dokumentationen är komplett” Skillnaden mellan ”fungerar” och ”fungerar inte” är verifierbarheten. Om ett kriterium inte går att kontrollera med ett kommando går det inte att kontrollera alls. Det är också vad OpenAI menar med ”sammanhang över långa tidshorisonter”: en agent kan tänka länge, men den kan inte själv avgöra vad som räknas som ”tillräckligt bra”. Du kan testa idén ”en prompt – ett resultat” i ett verkligt projekt: ange `/goal`, formulera ett kriterium, kör det och analysera vad som gick fel.
### Källor - [Claude Code-dokumentation om `/goal` (Anthropic)](https://code.claude.com/docs/en/goal) - [Ändringslogg för Claude Code (Anthropic)](https://code.claude.com/docs/en/changelog) - [Ändringslogg för OpenAI Codex](https://developers.openai.com/codex/changelog) - [OpenAI Codex Cookbook: Använda mål](https://developers.openai.com/cookbook/examples/codex/using_goals_in_codex) - [OpenAI-bloggen: Köra långsiktiga uppgifter med Codex (23 februari 2026)](https://developers.openai.com/blog/run-long-horizon-tasks-with-codex) - [GitHub openai/codex: continuation.md](https://github.com/openai/codex/blob/6014b6679ffbd92eeddffa3ad7b4402be6a7fefe/codex-rs/core/templates/goals/continuation.md) - [GitHub openai/codex: budget_limit.md](https://github.com/openai/codex/blob/6014b6679ffbd92eeddffa3ad7b4402be6a7fefe/codex-rs/core/templates/goals/budget_limit.md)
Lär känna [Ailoot](https://ailoot.ai/). ## Frågor om den här guiden: Så kör du Claude Code och Codex över natten via /goal år 2026: 14 timmars autonomt läge ### Vad är ett användbart slutförandekriterium för /goal? Använd ett kontrollerbart resultat: namnge test, typkontroll, bygge eller benchmark och krävt utfall. Kombinera krävda kontroller uttryckligen och ange tillåtna filer; ”gör det bättre” ger agenten ingen mätbar stoppunkt. ### Vad gör jag när agenten upprepar samma misslyckade ändringar? Avbryt körningen och granska loggen. Om den fortsätter ändra och återställa samma filer begränsar du uppgiften eller preciserar kriteriet; verifiera att nödvändiga kontroller faktiskt kan passera innan du återupptar. ## Ailoot · Företaget och dess projektportfölj Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll. Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder. Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.