Quickstart

Zet Muse Code in een paar minuten aan het werk.

Muse Code is algemeen beschikbaar voor macOS, Linux en Windows. Het pakt complexe software-engineeringtaken op in grote repositories — wijzigingen plannen, code schrijven en de resultaten valideren — volledig vanuit je terminal.

1. Installatie

Eén commando installeert de CLI:

$curl -fsSL https://dev.meta.ai/install.sh | bash

Het script zet de muse-binary in je PATH — controleer het met muse --version. Wil je het script eerst nalezen? Download het met -o install.sh, controleer het en voer het daarna uit.

Windows

Windows heeft een eigen native installer: voer irm https://dev.meta.ai/install.ps1 | iex uit in PowerShell en controleer het resultaat met muse --version. Op Windows voert de agent commando’s uit in PowerShell in plaats van Bash, kan de sandbox bij de eerste start een UAC-melding tonen, en zijn spraakinvoer en berichten tussen sessies niet beschikbaar. Heb je die nodig, of wil je een Bash-toolchain, gebruik dan WSL2: voer wsl --install uit in een PowerShell met beheerdersrechten en draai daarna de macOS/Linux-installer in de Linux-shell. Zet die repositories op het Linux-bestandssysteem (bijvoorbeeld ~/code), niet onder /mnt/c, want bestandstoegang over die grens heen is veel trager.

2. Authenticatie

Bij de eerste run opent de browser om je aan te melden op dev.meta.ai met je Meta-ontwikkelaarsaccount. Inloggegevens worden lokaal gecachet — je hoeft je niet per sessie opnieuw aan te melden. Gebruik wordt gefactureerd via je maandabonnement of, bij pay-as-you-go, via de Meta Model API.

Niet-interactieve runs. Gebruik voor CI, scripts en headless machines een API key in plaats van de browserflow: maak er een aan in het Model API-dashboard (API keys → Create API key) en exporteer die als META_API_KEY of sla hem op met muse auth set. Keys beginnen met LLM_. Muse Code kijkt eerst naar META_API_KEY, dan naar een opgeslagen key en pas daarna naar een browsersessie; /login opent de aanmeldopties opnieuw en muse logout wist opgeslagen inloggegevens.

3. Voer je eerste taak uit

Zodra de authenticatie rond is, kun je in elk van je projectmappen aan de slag:

$ cd my-repo$ muse

Beschrijf in gewone taal welk resultaat je wilt. Een goede eerste taak is klein en verifieerbaar — "voeg de ontbrekende test voor parseDate toe en zorg dat hij slaagt" — je ziet dan een worker de wijziging opzetten, een reviewer er kritiek op leveren en de test draaien.

Twee kostenknoppen die je vanaf dag één wilt kennen: Muse Spark is een redeneermodel — het denkt na voordat het antwoordt, en die tokens worden als output gefactureerd — met /effort zet je het denkwerk per taak hoger of lager. En je toon, format en andere vaste regels kunnen in een system message staan, zodat je ze niet in elke prompt hoeft te herhalen.

Bijwerken & verwijderen

Muse Code werkt zichzelf bij: de installer zet een launcher op die de binary actueel houdt, en sinds CLI 1.4.11 gaat een sessie die tijdens een automatische update bleef draaien verder met haar geschiedenis. Met muse --version zie je welke versie je hebt; vergelijk die met de changelog. Het installatiecommando opnieuw uitvoeren levert ook de nieuwste build op. Meta documenteert geen commando om te verwijderen. Op macOS en Linux zet de installer de launcher in ~/.local/bin (muse, plus geversioneerde muse-bin-*-bestanden) en voegt die map toe aan je shellprofiel; verwijder je die bestanden, dan is Muse Code weg. Instellingen staan in ~/.config/muse/. Op Windows laat Get-Command muse zien waar de binary staat. Zeg een abonnement apart op in Accounts Center — de CLI verwijderen stopt de facturering niet.

Asynchrone achtergrondagents

Muse Code werkt met een eenvoudige agent-loop plus een set asynchrone achtergrondagents die de hoofdagent versterken. Deze gespecialiseerde agents blijven de hele sessie actief in plaats van per taak te worden gestart, zodat informatie niet dubbel wordt verzameld. Ze voeren vervolgstappen zelfstandig uit en kiezen zelf wanneer ze terugkoppelen naar de hoofdagent — doordat ze blijven draaien daalt de wachttijd en hoef je bij lastige taken met veel stappen minder bij te sturen.

Agent fan-out & git worktrees

Valt een klus uiteen in meerdere taken, dan waaieren die automatisch uit over aparte agents: de parent start per taak een child-agent met schrijfrechten, en elk child krijgt zijn eigen git worktree — parallelle children botsen nooit op dezelfde bestanden en je werkkopie blijft schoon.

Workflows

Workflows kwamen erbij toen Muse Code uit de bèta ging en orkestreren een team van gespecialiseerde agents rond een grotere klus: elke fase geeft zijn tussenresultaat door aan de volgende, en aan het eind krijg je één resultaat. Je start er een door Muse Code te vragen om "een workflow te gebruiken"; met effort op ultra kan er ook automatisch een starten. /workflows toont elke run live — daar kun je hem stoppen, herstarten of annuleren — en opgeslagen workflows zijn herbruikbaar.

Berichten tussen sessies

Sessies op dezelfde machine kunnen elkaar berichten sturen via een lokale Unix-socket. Raakt een wijziging in de ene sessie aan wat een andere aan het bouwen is, dan geeft die een waarschuwing door; lost de ene sessie een vraag op waar een andere op vastzit, dan stuurt die het antwoord — niets meer overtikken tussen terminals. De agent vindt de andere sessies en verstuurt berichten met twee ingebouwde tools.

Event log & terugspoelen

Muse Code gebruikt een lokaal event log waaraan elke modelaanroep, toolrun, goedkeuring en bewerking wordt toegevoegd. Deze enkele bron van waarheid maakt de runtime exact herafspeelbaar en veilig te herstarten: na een crash gaat de agent precies verder waar hij stopte, zodat hij langlopende taken aankan zonder door storingen uit koers te raken. Elke start, bijsturing en annulering van een subagent is waarneembaar — muse replay loopt stap voor stap door een sessie, en volledige traces zijn te exporteren voor overdracht of audit. Druk twee keer op Esc om het gesprek terug te spoelen naar een eerder punt; Muse Code biedt alleen terugspoelpunten aan die het event log als veilig markeert.

Meegeleverde skills & commando’s

Muse Code wordt geleverd met een aantal standaardskills — stop er een ruw idee in en krijg er een doorgezaagde, op smaak gecontroleerde feature uit:

/planZet een taak om in een plan dat eerst goedkeuring nodig heeft voordat er code wordt aangepast

/grillOnderwerpt dat plan aan stresstests tot het overeind blijft

/goalWerkt door tot het opgegeven doel succesvol is afgerond — wat je oorspronkelijk wilde, is wat gemerged wordt

/workflowsToont workflowruns live — stop, herstart of annuleer er een naar keuze

/modelWisselt het onderliggende model — bijv. naar muse-wonder-1.0; in de kiezer stel je ook het redeneerniveau in

/effortZet het redeneren hoger of lager — denktokens worden als output gefactureerd, dus bewaar diep redeneren voor lastige taken

Esc EscSpoelt het gesprek terug naar een veilig punt uit het event log

muse replayLoopt stap voor stap door het event log van een sessie; volledige traces zijn te exporteren voor overdracht of audit

Rechten & goedkeuringsmodi

Muse Code start met goedkeuringen en een sandbox op OS-niveau aan (Seatbelt op macOS, bubblewrap op Linux, de Windows-sandbox op Windows). Schrijven mag alleen in de workspace en een tijdelijke map, en .git, .muse en .agents blijven alleen-lezen. Nieuwe sessies beginnen in het profiel Auto-review: een ingebouwde beoordelaar handelt routinematige goedkeuringsverzoeken af en legt de rest aan jou voor. De andere profielen zijn Ask me, Read-only en Unrestricted. Het standaardprofiel stel je in met permissions.default_profile in ~/.config/muse/settings.json. De flags die ertoe doen:

--approval-mode on-requestStandaard. Veilige shellstappen draaien gewoon; gevaarlijke zoals rm -rf wachten op een review

--approval-mode untrustedStrenger: elke shellstap zonder bijpassende allow-regel wacht op een review

--approval-mode neverNiets wacht op goedkeuring; alleen de sandbox houdt in toom wat er draait

--disable-approvalSlaat de goedkeuringsprompts over, maar laat de sandbox aan

--yoloGeen goedkeuringen, geen sandbox, workspace geldt als vertrouwd. Volgens Meta alleen te gebruiken in wegwerpbare, geïsoleerde containers

--sandbox-networkproxy-only (standaard, keurt elke bestemming afzonderlijk goed), restricted of unrestricted

Wordt een commando tegengehouden, dan kun je het één keer toestaan, altijd toestaan in deze workspace of weigeren. MCP-tools en hooks draaien buiten de sandbox, dus koppel alleen servers die je vertrouwt.

Muse Spark 1.3

Muse Spark 1.3, uitgebracht op 2 september 2026, is het model achter Muse Code. Het houdt vast aan het trainingsrecept waarmee 1.2 zich onderscheidde — samen getraind met de Muse Code-harness, uitgebreid langlopend werk en een zelfverbeteringslus — en richt zich op bruikbaarheid in de praktijk. De prijs is gelijk aan die van 1.2. Drie dingen springen eruit:

Langere threads

Houdt langlopend werk vol over meerdere workflows binnen één thread en neemt de context mee van de ene fase naar de volgende.

Vraagt in plaats van te gokken

Werkt actiever samen: het stelt verhelderende vragen, meldt wanneer het vastloopt en schat zijn eigen grenzen beter in, in plaats van resultaten te rapporteren die het niet heeft gehaald.

Zuinigere runs

In vergelijkingen van Meta-engineers deed het hetzelfde codeerwerk met zo’n 20% minder toolaanroepen en 25% minder tokens dan 1.2 — bij dezelfde prijs per token betekent dat een lagere rekening.

Benchmarks (maximale redeneerconfiguratie, volgens Meta): DeepSWE 1.1 · 75,4% — Terminal-Bench 2.1 · 88,8% — SWEAtlas CodeBase QnA · 59,4%. Bij de lancering zat de maximale configuratie nog in veiligheidstests; de configuratie die de meeste ontwikkelaars krijgen, scoort lager. Methodologie op research.meta.ai.

Muse Wonder

Muse Wonder en Muse Wonder Full, uitgebracht op 12 oktober 2026, zijn de eerste frontiermodellen van Meta: groter dan Muse Spark en bedoeld voor lang, lastig werk in programmeren en in vakgebieden als recht en financiën. Meta licht vooral Active Memory uit, dat relevante context van het ene gesprek naar het andere meeneemt, en Active Focus, dat een agent op zijn doel gericht houdt en vóór belangrijke acties eerst bij je navraagt. Schakel over naar Wonder met /model muse-wonder-1.0; via de API kost het $4 / $0.20 / $20 per 1M input- / cached / outputtokens, zonder Contributor-variant. Muse Wonder Full zit alleen in de abonnementen Power en Maximum.

Muse Spark Open

Muse Spark Open, uitgebracht op 15 oktober 2026, is een Muse-model met open gewichten: 816B parameters in totaal, 42B actief per token, een context van 1M tokens en invoer in de vorm van tekst, beeld, video en audio. Het valt onder de Muse Model License, een eigen licentie van Meta, en de gewichten staan op Hugging Face als meta-models/Muse-Spark-Open-816B-A42B. Dit is geen model voor je laptop: in NVFP4 heeft het zo’n 700 GB acceleratorgeheugen nodig. Meta heeft Muse Code erop laten draaien op twee Mac Studios, maar heeft geen lokale setup gedocumenteerd. Zoek je een model dat op één consumenten-GPU past, kijk dan naar Muse Glimmer.

Casestudy: kerneloptimalisatie

Meta testte hoe goed Muse Spark 1.2 GPU-kernels iteratief kan optimaliseren over 1.000+ toolaanroepen — tot 24 uur lang. Binnen de agentomgeving van Muse Code schrijft, compileert en profileert het model kernels en verbetert het de prestaties stap voor stap ten opzichte van een baseline, gemeten op KDA- en MLA-kernels voor NVIDIA Hopper-GPU’s. Omdat het geen kernel-libraries van derden mocht wrappen, implementeerde het de algoritmen rechtstreeks in Triton — en bleef het substantiële verbeteringen ten opzichte van de baseline vinden.

Meta Model API

Dezelfde modellen achter Muse Code zijn ook rechtstreeks beschikbaar — `muse-spark-1.3` en `muse-wonder-1.0` staan in de Model API, en Muse Spark 1.3 is daarnaast beschikbaar in Muse Code, de Meta Model API, OpenRouter en Cursor. De API is drop-in compatibel met de OpenAI SDK, de Anthropic SDK en agent-CLI’s zoals OpenCode en Claude Code: richt je client op de base URL en laat de rest van je code ongemoeid. Het contextvenster is 1.048.576 tokens.

# export MODEL_API_KEY="LLM_..."client = OpenAI( base_url="https://api.meta.ai/v1", api_key=os.environ["MODEL_API_KEY"], ) response = client.chat.completions.create( model="muse-spark-1.3", messages=[{"role": "user", "content": "Hello, world!"}], )

Headless draaien & CI

muse exec "<prompt>" voert één taak tot het eind uit en stopt dan — de vorm voor scripts en CI. Voeg --json toe voor JSONL-events op stdout, --prompt-file om de prompt uit een bestand te lezen, --max-model-steps om het werk te begrenzen en --session-id om een eerdere sessie voort te zetten. Authenticeer met META_API_KEY uit de secret store van je CI. Exitcode 0 betekent dat de beurt klaar is, niet dat het werk klopt, dus laat merges afhangen van je eigen tests. Op Linux-runners heeft de sandbox bubblewrap en een build zonder musl nodig.

# CI: key from your secret store, JSONL events on stdout$ META_API_KEY="$MUSE_KEY" muse exec --json "fix the failing test in tests/date.test.ts"

Muse-modellen in andere agents

Meta documenteert hoe je OpenCode, Codex en Claude Code op de Model API aansluit. Gebruik de OpenAI-compatibele base-URL https://api.meta.ai/v1 (voor OpenCode en Codex) of de base-URL in Anthropic-formaat https://api.meta.ai zonder /v1 (voor Claude Code), samen met je MODEL_API_KEY en een model-ID zoals muse-spark-1.3 of muse-wonder-1.0. Stel in Claude Code ANTHROPIC_AUTH_TOKEN in, niet ANTHROPIC_API_KEY, en laat elke modelalias naar een Muse-model wijzen, zodat niets terugvalt op Claude. Gebruik in Codex wire_api = "responses", zodat de redenering over beurten heen behouden blijft. Dit wordt per token afgerekend via de Model API; je Muse Code-abonnement dekt het niet.

# Claude Code on Meta's Model APIexport ANTHROPIC_BASE_URL="https://api.meta.ai"export ANTHROPIC_AUTH_TOKEN="$MODEL_API_KEY"export ANTHROPIC_MODEL="muse-wonder-1.0"export ANTHROPIC_DEFAULT_OPUS_MODEL="muse-wonder-1.0"export ANTHROPIC_DEFAULT_SONNET_MODEL="muse-spark-1.3"export ANTHROPIC_DEFAULT_HAIKU_MODEL="muse-spark-1.3"export CLAUDE_CODE_SUBAGENT_MODEL="muse-spark-1.3"

Muse Code-SDK

De SDK, sinds het einde van de bèta van Muse Code beschikbaar als developer preview, laat teams hun eigen agents bouwen op het Muse Session Protocol (MSP) — een open protocol via standaard-I/O, zonder server en zonder netwerk, zodat alles op je eigen machine blijft. De TypeScript-library dekt sessies, tools en permissiebeheer, en met het machineleesbare schema van MSP genereer je clients in andere talen. Broncode: github.com/meta-models/muse-code-sdk.

Cookbook

Recepten die meteen bij de eerste kopie draaien — elk lost één afgebakend probleem op, laat werkende code zien en wijst je de volgende stap. Drie secties, plus recepten voor de kernpatronen van Muse Code.Bekijk alle 28 recepten →

API-basis · 10 recepten

Bewijs dat elke primitive werkt: chat completions, streaming, tool calling, gestructureerde output, prompt caching, redeneertokens, visuele input, lange context, foutafhandeling en search grounding met inline citaten.

Agentpatronen · 5 recepten

De loops die van een model een agent maken: de waarnemen-beslissen-handelen-loop, redeneren afgewisseld met toolgebruik, contextbeheer over meerdere beurten en gevalideerde in-place-bewerkingen.

Toepassingen · 13 recepten

End-to-end: in de browser geverifieerd webdesign en gamedevelopment, een multi-agent-productstudio met vier profielen die samenwerken via een gedeeld kanbanbord, een autonome GitHub Actions-bot op OpenCode, computergebruik op Linux en macOS, en meer.

Muse Code-recepten

Agent fan-out — verdeel één grote klus over subagents in geïsoleerde worktrees; meegeleverde skills — ruw idee erin, doorgezaagde, gecontroleerde feature eruit; goal tracking — houd een agent op koers tot hij merget wat je wilde.