How to Install and Use Meta's Muse Code Agent

You want a coding agent running in your terminal, you have never installed one, and every walkthrough you can find assumes you already pay for Claude Code or OpenAI's Codex. Meta's Muse Code has been in beta since August 5, 2026, and its cheap tier bills $0.10 per million input tokens against $1.25 on the standard one. The install is a single line, and the first command worth typing is /plan.

Five steps from an empty terminal to an approved plan

The install line, the bundled skills and the runtime behaviour below come from Meta's launch post. The prices come from developer-page figures posted by commenter tristanj in the Hacker News thread (263 points, 164 comments), because Meta's post carries none.

1. Check that you are on macOS or Linux. Meta published a bash installer, so those are the two platforms it runs on as written.
2. Read the installer before you pipe it into a shell. The published line is curl -fsSL https://dev.meta.ai/install.sh | bash. That executes whatever the server returns at the instant you press enter, on the machine holding your source code and your SSH keys. Pull it down first with curl -fsSL https://dev.meta.ai/install.sh -o muse-install.sh, open it in an editor, then run bash muse-install.sh. This is the one step on the list that git cannot undo for you.
3. Choose your tier before you generate a key. Both prices live behind the same developer account at dev.meta.ai. Standard is $1.25 per million input tokens and $4.25 per million output. Contributor is $0.10 and $0.20, and Meta trains on what you send it. Make that call with the actual repository in front of you, not in the abstract: client work under an NDA and anything you would not paste into a public gist belongs on the standard tier, and a side project you would happily open-source does not.
4. Open a git repository with a clean working tree. Muse Code edits files on disk. If the directory is not a repo yet, git init && git add -A && git commit -m "before muse" takes four seconds and turns every subsequent mistake into git checkout .. This matters more for a first-time user than any setting in the tool, because git diff is how you read what the agent did when the approval prompt tells you it wants to touch nine files.
5. Run /plan, then /grill, then approve. Meta's post documents /plan, /grill and /goal out of several bundled default skills. /plan turns a task into an approval-gated plan, /grill stress-tests that plan until it holds, and /goal works toward a stated objective. For a first run, give /plan one plain sentence, something like adding a dark-mode toggle that remembers the setting, then /grill it, then read the plan before you approve anything.

That approval gate is the part beginners should lean on hardest. It is the difference between an agent that proposes nine file edits and one that makes them while you are reading the proposal.

/goal is the other mode, and it is a different kind of session. Meta describes a simple main agent loop plus asynchronous background agents that "remain active throughout each session, rather than being spawned for individual tasks," gathering context once instead of repeatedly and deciding for themselves when to report back. Underneath sits an append-only local event log: every model call, tool run, approval and edit is written to it, which Meta says makes the agent "replay-exact and restart-safe." Close the laptop lid on a running session and the run resumes from where it stopped rather than from the beginning.

Screenshots are legitimate input. Muse Spark 1.2 is a coding-focused revision of Muse Spark 1.1, which shipped multimodal, and one Hacker News commenter weighing Muse Code against DeepSeek V4-Flash listed built-in vision as a reason to pick it. If the bug is visual, showing it beats describing it.

$0.10 and $1.25, the two prices you are choosing between

Both rows below are the developer-page figures posted by tristanj on Hacker News, since Meta's launch post publishes no pricing at all.

Ten times off input and twenty times off output is a real number attached to a real trade, which is more than the vague data-sharing toggle buried in most settings pages gives you. For someone who has never paid for AI coding help, the contributor tier is the honest entry point: a personal project, a public repo, and a bill measured in cents rather than a $20 monthly subscription you signed up for before knowing whether the thing works.

One caveat on the free credits. A developer who took Meta's $20 signup credits at the Muse Spark 1.1 launch flagged new small print on them in the same thread, "While using free credits your content may be used for product improvement," which they say was not present when the credits were issued.

1,000 tool calls and no spending limit you can set

Muse Code is built to run unattended for a long time. Meta's own headline case study has it making more than 1,000 tool calls across as much as 24 hours, writing, compiling and profiling Triton implementations of KDA and MLA kernels for NVIDIA Hopper GPUs. Billing is per token, metered, with no ceiling exposed to you.

What this looks like when it goes wrong is nothing. There is no error, no wall, no prompt. Commenter sams99 in the Hacker News thread entered a credit card, found no way to set a limit, only an email alert, and described the position as being "one oopsie away from getting a 100 dollar bill." ray_kay777 said they would not try the product at all without a top-up model.

The workaround developers in the thread landed on is routing through OpenRouter, which enforces hard per-key spending limits. You give up the discounted first-party endpoint to get it, so the contributor tier and a hard cap are not currently available at the same time.

Until you have a feel for what a session costs, the practical defence is behavioural rather than technical. Use /plan and approve step by step for anything short, and reserve /goal for tasks where you already know roughly how long the work should take.

8 seconds of silence that is not a crash

Two things make a healthy Muse Code session look broken to someone who has only used a chat window.

The first is latency at the start. Throughput reports on OpenRouter put Muse Spark 1.2 at roughly 150 to 180 tokens per second, against something closer to 50 for most DeepSeek providers, with time to first token around 8 seconds. Those figures come from an OpenRouter dashboard rather than an independent benchmark, so treat them as a rough shape. The behaviour they describe is a fast model with a slow start, which reads as a hang for the length of time it takes to wonder whether you typed the command wrong.

The second is designed silence. Because background agents stay alive across the session and decide for themselves when to report back to the main loop, a quiet terminal during a /goal run can mean subagents are working rather than that anything stalled. The event log is the check that costs nothing: it records every model call and tool run as they happen, so a session that is genuinely progressing is a session whose log keeps growing.

And if the process really does die, that same append-only log is why you restart rather than start over. Meta's claim is that a crashed run resumes exactly where it stopped.

Two regions where the cheap tier is not offered

The $0.10 price is not available everywhere. Several commenters in the Hacker News thread report the contributor tier as US-only, with the EU and Australia excluded, which is the kind of restriction you would expect on a tier whose entire mechanism is a data-licensing agreement.

If you are outside the US, the arithmetic changes completely. You are comparing $1.25 and $4.25 per million tokens against Grok Build, Codex, Claude Code and DeepSeek V4-Flash, and the ten-times discount that makes Muse Code interesting to a first-time buyer is simply not on the menu. Check which tiers your account is actually offered before you plan a workflow around the cheap one.

The wrong tool for code you cannot check

Look at what Meta tuned this thing on. The kernel case study runs for up to 24 hours and more than 1,000 tool calls because compiling and profiling give the agent a verdict on every iteration, with third-party kernel libraries like FLA explicitly banned from the imports so the work could not be shortcut. Meta also co-trained Muse Spark 1.2 on rejection-sampled trajectories from the Muse Code harness itself, which is to say the model was shaped by sessions where success was machine-checkable.

Hand the same machinery a task with no such check and every design decision turns against you. Persistent subagents, restart-safe replay and uncapped metered billing add up to a system that will spend an hour and real money travelling confidently in a direction you would have stopped in the first minute, because nothing in the loop is measuring the thing you care about.

The top-voted critique in the Hacker News discussion is about model selection, and it applies here too: Meta benchmarked against OpenAI's mid-tier Terra rather than GPT-5.6 Sol, and left Claude Opus 5 in a chart where Muse Spark 1.2 loses all but one comparison. Multiple commenters claiming familiarity with Meta say its own engineers are still working in Claude Code or Codex.

So if you do not yet have a project with a test suite, a build step, or at minimum a page you can load and look at, do not run the installer. The Meta AI app has carried a Muse Spark model free for consumers since the 1.1 launch in July, and that is the cheaper place to find out whether this family of models is any good at your kind of problem before you hand one a shell.