How to Use Muse Wonder: Install Muse Code on Windows 11, Mac and Kali Linux, Run It in Claude Code, Codex or OpenCode, and Call It From Python or AWS Lambda (Pricing vs Claude Opus 5.5)

Muse Wonder is Meta's new closed AI model for coding and agents, released on October 12, 2026. You can't download it, but you can use it from your own Windows 11, Mac or Kali Linux machine in three ways: install Muse Code, Meta's terminal coding agent, with one command; point the agent you already use, Claude Code, Codex or OpenCode, at Meta's API; or call it from your own Python or Node.js code, including AWS Lambda. Every route uses the model ID muse-wonder-1.0 and costs $4 per million input tokens and $20 per million output tokens. Here's the catch that trips almost everyone on day one: a fresh Muse Code install doesn't run Muse Wonder at all. Its default model is Muse Spark 1.2, so you have to switch it yourself. And Meta's API keys contain pipe characters (LLM|…|…) that silently break the usual export command unless you quote them. This page walks through every install and setup step on each system, the exact configs for each agent, tested code for Python, Node.js and AWS Lambda, what it really costs next to Claude Opus 5.5, and the fix for every error you're likely to meet.

Ethan, a developer, looks after the booking app on his friend Jake's phone repair shop website. On Tuesday morning Jake forwarded him a headline about Meta's new model with one line: "Can we use this? Can you try it on the shop code?" Ethan works on a Kali Linux laptop; the shop's office PC runs Windows 11. He decided to try Muse Wonder on both, the way a careful developer tries anything new: through the tools he already uses first, and only then in a small piece of AWS code. This page is that afternoon, step by step, including the two places where things quietly went wrong.

New to AI APIs? A "token" is a small piece of text, roughly three to four characters of English, and models charge per million of them. Our plain-English guide to tokens and AI pricing explains it in a few minutes.

What Muse Wonder is, and the three ways to use it from your PC

Muse Wonder is the top model in Meta's Muse family, built for long software and agent work: changes across many files, plans that run for hours, sub-agents and tool calls. It takes text, images, video, audio and PDFs, answers in text, and has a 1,048,576-token context window. It comes in two versions: Muse Wonder, which anyone can use through the Meta Model API and Muse Code, and the stronger Muse Wonder Full, which only runs inside Muse Code on the two biggest subscription plans.

Because it's closed, "running it locally" means running the tools on your machine while the model answers from Meta's servers. Here are the three routes, side by side:

One thing to know before you look for it elsewhere: Muse Wonder isn't on Amazon Bedrock. On October 13, 2026, Meta's only models in Bedrock's catalog are Llama models. So on AWS you call Meta's API from your own code, which the Lambda section shows.

Jake: "So we can't put it on the shop PC like those offline models you showed me."

Ethan: "The tools go on the PC, the brain stays at Meta. It's like a phone app that needs signal. Fine for the booking code, as long as we're careful with the key."

Step 1: Get a Meta API key, and quote it

Muse Code can sign you in through the browser, so you can skip this step if that's the only route you'll use. For Claude Code, Codex, OpenCode and your own code, you need an API key:

1. Sign in to the Model API dashboard at dev.meta.ai and open the API keys tab.
2. Select Create API key, give it a name that says where it will be used (for example "kali-laptop"), and create it.
3. Copy it right away. You only see it once.
4. Have a team admin add a payment method under Billing. Without one, calls fail with a billing error even though the key is valid.

Meta's keys look like this: LLM|607358788850350|nx9.....LJY. Those two vertical bars are the trap. In a terminal, | means "pipe the output into the next command," so this common line breaks:

export MODEL_API_KEY=LLM|607358788850350|nx9abcLJY

On Kali's default shell, zsh, it prints command not found: 607358788850350, and bash prints 607358788850350: command not found. Worse, the variable ends up empty, so every call afterward fails with an authentication error that seems to have nothing to do with the line you typed. Put the key in double quotes and it works:

export MODEL_API_KEY="LLM|607358788850350|nx9abcLJY"
echo "$MODEL_API_KEY"

To keep it after you close the terminal, add that export line, quotes included, to ~/.zshrc on Kali or a Mac, or ~/.bashrc if you use bash.

On Windows 11, in PowerShell, quotes are needed too. The first line sets the key for the current window; the second saves it for your account, so new windows get it:

$env:MODEL_API_KEY = "LLM|607358788850350|nx9abcLJY"
[Environment]::SetEnvironmentVariable("MODEL_API_KEY", "LLM|607358788850350|nx9abcLJY", "User")

Leave the quotes out in PowerShell and it refuses the line with Expressions are only allowed as the first element of a pipeline., the same pipe problem in different words.

Treat the key like a password. Keys on the same team share one set of rate limits, so a leaked key can use up your team's quota as well as your money. Use a separate key for each machine or app, so you can delete one without breaking the rest.

Jake: "So the line looked fine, and the key just vanished."

Ethan: "Exactly. The terminal thought half the key was a command. Two quote marks fix it, and you'd never guess from the error."

Step 2: Install Muse Code on Windows 11, Mac and Kali Linux

Muse Code is Meta's coding agent for the terminal. You run it inside a project folder, and it plans changes, edits files and runs commands, asking for your approval and working inside a sandbox from the first run. It installs as a single native program called muse.

Kali Linux, other Linux and macOS

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

What the installer does, so nothing surprises you:

• It puts muse in ~/.local/bin. To install somewhere else, set MUSE_INSTALL_DIR first.
• It adds that folder to your PATH by appending one line to your shell's startup file. On Kali, where the default shell is zsh, that's ~/.zshrc; with bash it's ~/.bashrc. If you'd rather edit PATH yourself, set MUSE_NO_MODIFY_PATH=1 before installing.
• It works on 64-bit Intel and AMD processors and on ARM64, on both Linux and macOS. It needs bash and curl, which Kali and macOS already have.
• It checks the downloaded launcher's checksum when the server provides one, and the launcher then fetches the matching muse program for your system.

When it finishes, the new PATH line isn't active in the window you're in. Open a new terminal, or load it into the current one:

source ~/.zshrc
muse --version

Windows 11

Open PowerShell (no administrator rights needed) and run:

irm https://dev.meta.ai/install.ps1 | iex

The installer puts Muse Code in %LOCALAPPDATA%\Programs\muse, adds that folder to your account's PATH, and supports both regular x64 PCs and ARM64 laptops such as Snapdragon models. It starts Muse Code through a small muse.cmd wrapper, so you don't need to change PowerShell's script execution policy. Open a new PowerShell window afterward, then run muse --version.

Windows differs in three small ways: the agent runs PowerShell commands instead of Bash, the sandbox may show a User Account Control prompt the first time it starts, and voice input and session messaging aren't available on Windows.

First run

cd /path/to/your/project
muse

On the first start, Muse Code asks whether you trust the folder (trusting it lets it load the project's rules, skills and hooks), then asks you to sign in: through your browser, or by pasting an API key. Your choice is stored, and /login reopens the options later. If your organization signed up through Meta's Business & Enterprise route, use the API key option; those accounts can't use the browser sign-in.

A nice surprise if you already use Claude Code: Muse Code reads your existing project instructions. It looks for AGENTS.md, CLAUDE.md, .agents/AGENTS.md and .claude/CLAUDE.md in each folder up to the repository root, so the house rules you wrote for one agent carry over. Run muse init to create an AGENTS.md if you don't have one.

Step 3: Switch Muse Code to Muse Wonder (it starts on Muse Spark 1.2)

This is the step most first-day reviews skip. A new Muse Code install uses Muse Spark 1.2 as its default model, not Muse Wonder. You choose Wonder in one of two ways:

muse --model muse-wonder-1.0

or, inside a running session, type /models and pick it from the list. To make it your everyday default without remembering the flag, add an alias to your shell (Kali or Mac):

echo "alias muse='muse --model muse-wonder-1.0'" >> ~/.zshrc
source ~/.zshrc

On Windows, add a function to your PowerShell profile instead:

Add-Content $PROFILE 'function musew { muse --model muse-wonder-1.0 @args }'

Then open a new PowerShell window and start it with musew. On a new PC the profile file may not exist yet; if Add-Content complains that it can't find part of the path, create it first with New-Item -ItemType File -Path $PROFILE -Force, then run the line again.

Two more settings matter:

• Reasoning effort. --reasoning-effort (or /effort mid-session) trades speed for depth: minimal, low, medium, high (the default), xhigh and max. Use low or medium for quick edits and save max for the hard problems, because deeper reasoning means more output tokens, and output is the expensive side of the bill. Meta's models don't accept none.
• Muse Wonder Full. The stronger version appears only on the Power Usage and Maximum Usage subscription plans. Setting effort to max on plain Muse Wonder doesn't switch you to Full.

For scripts and CI pipelines, Muse Code has a headless mode that runs one prompt to the end:

META_API_KEY="$MODEL_API_KEY" muse exec --model muse-wonder-1.0 "Run the test suite and summarize the failures."

Notice the variable name. Muse Code reads META_API_KEY, while the API setup on this page, including Claude Code and Codex, uses MODEL_API_KEY. Same key, two names; mixing them up is the most common reason a CI run says it isn't signed in. An API key always wins over a browser sign-in, and muse logout clears stored credentials but not a key you exported yourself.

Your settings live in ~/.config/muse/settings.json. If you create that file by hand, it must contain "schema_version": 1, or every command fails at startup with malformed settings file. If you don't need it, don't create it; Muse Code runs fine with its defaults.

Jake: "So if you hadn't checked, you'd have spent the afternoon testing the wrong model."

Ethan: "And told you Meta's new model was fine but nothing special. Always check which model is actually answering."

Use Muse Wonder in Claude Code, Codex or OpenCode

If you already have a favorite coding agent, keep it. The Meta Model API speaks two formats: an OpenAI-style one at https://api.meta.ai/v1 (the Responses and Chat Completions APIs), and an Anthropic-style Messages API at https://api.meta.ai. Agents built for either can use Muse Wonder with a few settings.

Claude Code

Claude Code reads its provider from environment variables. On Kali or a Mac:

export 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-wonder-1.0"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="muse-wonder-1.0"
export CLAUDE_CODE_SUBAGENT_MODEL="muse-wonder-1.0"
export ENABLE_TOOL_SEARCH="true"
claude

On Windows 11, the same in PowerShell:

$env:ANTHROPIC_BASE_URL = "https://api.meta.ai"
$env:ANTHROPIC_AUTH_TOKEN = $env:MODEL_API_KEY
$env:ANTHROPIC_MODEL = "muse-wonder-1.0"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL = "muse-wonder-1.0"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL = "muse-wonder-1.0"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL = "muse-wonder-1.0"
$env:CLAUDE_CODE_SUBAGENT_MODEL = "muse-wonder-1.0"
$env:ENABLE_TOOL_SEARCH = "true"
claude

Three details make or break it:

• No /v1 on the base URL. Claude Code adds /v1/messages itself.
• ANTHROPIC_AUTH_TOKEN, not ANTHROPIC_API_KEY. The first sends the key as Authorization: Bearer, which is what Meta reads. The second sends it in an x-api-key header, and every request is refused as unauthorized.
• Pin every model alias. Claude Code quietly uses its "opus", "sonnet" and "haiku" aliases for Plan Mode, subagents and background jobs such as commit messages. If any of them still names a Claude model, those requests go to Meta asking for a model it doesn't serve, and fail. For cheaper background work you can point the haiku alias at muse-spark-1.3 instead.

Our Claude Code setup guide covers installing Claude Code itself on all three systems. To go back to your normal setup, close the terminal, or remove those lines from your shell profile if you saved them there.

Codex

Codex drives Muse Wonder over the Responses API, which carries the model's reasoning from one step to the next. Put this in ~/.codex/config.toml:

model = "muse-wonder-1.0"
model_provider = "meta"
model_reasoning_effort = "high"
model_reasoning_summary = "auto"
model_context_window = 1048576
model_supports_reasoning_summaries = true
model_auto_compact_token_limit = 900000

[model_providers.meta]
name = "Meta Model API"
base_url = "https://api.meta.ai/v1"
env_key = "MODEL_API_KEY"
wire_api = "responses"

Then run codex with MODEL_API_KEY set. If Codex is signed in to an OpenAI account, run /logout first so it uses the Meta provider. To try it without touching your normal Codex setup, start it with CODEX_HOME pointing at an empty folder; Codex then keeps this config, its sign-in and history there instead.

OpenCode

Add Meta as a provider in opencode.json (globally at ~/.config/opencode/opencode.json, or in your project):

{
  "provider": {
    "meta": {
      "name": "Meta Model API",
      "npm": "@ai-sdk/openai",
      "options": {
        "baseURL": "https://api.meta.ai/v1"
      },
      "models": {
        "muse-wonder-1.0": {
          "name": "Muse Wonder",
          "reasoning": true,
          "limit": {
            "context": 1048576,
            "output": 131072
          },
          "modalities": {
            "input": ["text", "image", "pdf", "video"],
            "output": ["text"]
          },
          "options": {
            "reasoningEffort": "high",
            "reasoningSummary": "auto",
            "include": ["reasoning.encrypted_content"]
          }
        }
      }
    }
  }
}

Run /connect, choose the meta provider, paste your key, restart OpenCode and select Muse Wonder. Keep the @ai-sdk/openai adapter and the include line: together they let the model keep its earlier reasoning between steps, and they let you paste images and PDFs directly. The simpler @ai-sdk/openai-compatible adapter also connects, but the model starts each turn from scratch and can lose the thread in long tasks. Our OpenCode guide covers installing it.

Whichever agent you use, don't worry if it shows a cost of $0. Custom providers usually have no price information in the agent, so the counter stays at zero while Meta bills you normally. Watch the usage page in Meta's dashboard instead.

Call Muse Wonder from Python, Node.js or curl

For your own scripts and apps, you don't need a Meta-specific library. The OpenAI SDK works with a different base URL, and the Anthropic SDK works through the Messages API.

Python with the OpenAI SDK

pip install openai

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)

response = client.responses.create(
    model="muse-wonder-1.0",
    reasoning={"effort": "high"},
    input="Plan the steps to add booking reminder emails to a small Flask app.",
)

print(response.output_text)
print("cached input tokens:", response.usage.input_tokens_details.cached_tokens)

Pass the key explicitly, as above. The OpenAI SDK looks for OPENAI_API_KEY by itself, not MODEL_API_KEY, and without a key it stops with Missing credentials. Please pass an `api_key`.... The cached_tokens line is worth keeping: cached input costs $0.20 per million tokens instead of $4, so if a long, repeated prompt shows zero there, your caching isn't working.

Python with the Anthropic SDK

import os
from anthropic import Anthropic

client = Anthropic(
    base_url="https://api.meta.ai",
    auth_token=os.environ["MODEL_API_KEY"],
)

message = client.messages.create(
    model="muse-wonder-1.0",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain a race condition in two sentences."}],
)

print(message.content[0].text)

Use auth_token=, not api_key=, for the same reason as in Claude Code: api_key sends the key in an x-api-key header, and Meta expects Authorization: Bearer. The Messages API keeps no conversation on Meta's side, so send the earlier turns with each request, exactly as you would with Anthropic.

Node.js

npm install openai

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.meta.ai/v1",
  apiKey: process.env.MODEL_API_KEY,
});

const response = await client.responses.create({
  model: "muse-wonder-1.0",
  reasoning: { effort: "medium" },
  input: "Write a one-line commit message for a typo fix in README.md.",
});

console.log(response.output_text);

Save it as index.mjs (the .mjs ending lets you use import and top-level await) and run node index.mjs.

curl

curl -X POST "https://api.meta.ai/v1/responses" \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "muse-wonder-1.0", "input": "What is the capital of France?"}'

On Windows, PowerShell's own command is easier than curl's quoting:

$body = @{ model = "muse-wonder-1.0"; input = "What is the capital of France?" } | ConvertTo-Json
Invoke-RestMethod -Method Post -Uri "https://api.meta.ai/v1/responses" `
  -Headers @{ Authorization = "Bearer $env:MODEL_API_KEY" } `
  -ContentType "application/json" -Body $body

One API detail that catches people: reasoning effort goes in a different place depending on the endpoint. On the Responses API it's nested, "reasoning": {"effort": "high"}; on Chat Completions it's top-level, "reasoning_effort": "high". And reasoning tokens count toward your output limit and your bill, so at high effort give the response a generous max_output_tokens, or the visible answer can be cut short.

Run Muse Wonder on AWS: a Lambda function with the key in Secrets Manager

Since Muse Wonder isn't on Bedrock, the AWS way to use it is to call Meta's API from your own function. Here's a small Lambda function that answers a question, with the key kept in AWS Secrets Manager instead of in the code or a plain environment variable. It runs on the Python 3.13 runtime.

1. Store the key

aws secretsmanager create-secret --name meta/model-api-key \
  --secret-string 'LLM|607358788850350|nx9abcLJY'

Single quotes, for the same pipe reason as before. Note the secret's ARN from the output.

2. The function

import json
import os

import boto3
from openai import OpenAI

secrets = boto3.client("secretsmanager")
_client = None


def get_client():
    global _client
    if _client is None:
        key = secrets.get_secret_value(SecretId=os.environ["MODEL_API_KEY_SECRET"])["SecretString"]
        _client = OpenAI(base_url="https://api.meta.ai/v1", api_key=key, timeout=120)
    return _client


def lambda_handler(event, context):
    question = json.loads(event.get("body") or "{}").get("question", "Say hello in five words.")
    response = get_client().responses.create(
        model="muse-wonder-1.0",
        reasoning={"effort": "low"},
        input=question,
    )
    return {
        "statusCode": 200,
        "headers": {"Content-Type": "application/json"},
        "body": json.dumps({"answer": response.output_text}),
    }

Save it as lambda_function.py. The client is created once and reused while the function stays warm, so the secret is read on the first request rather than on every one.

3. Package it for Lambda's Linux, even from Windows or a Mac

The openai package isn't built into Lambda, and two of its dependencies, pydantic_core and jiter, are compiled code. A plain pip install on Windows or a Mac downloads versions for your machine, and Lambda then fails to load them. Ask pip for Lambda's Linux versions explicitly:

pip install --platform manylinux2014_x86_64 --implementation cp --python-version 3.13 \
  --only-binary=:all: --target package openai
cp lambda_function.py package/
cd package && zip -r ../muse-wonder.zip . && cd ..

The result is about 11 MB zipped, comfortably under Lambda's direct-upload limit. If you've hit errors like "invalid ELF header" before, our guide to packages built on the wrong machine explains why this flag matters.

4. Permissions and deployment

The function needs a role that can write logs and read that one secret. Save this trust policy as trust.json:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": {"Service": "lambda.amazonaws.com"},
    "Action": "sts:AssumeRole"
  }]
}

Then create the role and the function, replacing SECRET_ARN and ROLE_ARN with your values:

aws iam create-role --role-name muse-wonder-lambda \
  --assume-role-policy-document file://trust.json
aws iam attach-role-policy --role-name muse-wonder-lambda \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam put-role-policy --role-name muse-wonder-lambda --policy-name read-meta-key \
  --policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"secretsmanager:GetSecretValue","Resource":"SECRET_ARN"}]}'
aws lambda create-function --function-name muse-wonder-ask \
  --runtime python3.13 --handler lambda_function.lambda_handler \
  --role ROLE_ARN --zip-file fileb://muse-wonder.zip \
  --timeout 120 --memory-size 512 \
  --environment "Variables={MODEL_API_KEY_SECRET=meta/model-api-key}"

Two settings in that last command matter more than they look. Lambda's default timeout is 3 seconds; importing the SDK alone can take that long on a cold start, before Muse Wonder has started thinking, so 120 seconds gives it room. And if you put API Gateway in front, its REST API integration gives up at 29 seconds by default while your function keeps running; for long agent tasks, use Meta's background responses or an asynchronous design. Our API Gateway timeout guide walks through both.

Jake: "Why not just paste the key into the code? It's our code."

Ethan: "Because code gets copied, zipped and shared, and that key spends real money. In Secrets Manager only this one function can read it."

What Muse Wonder costs: the same price as Claude Opus 5.5

On the Meta Model API, Muse Wonder is billed per token, with no minimums:

Prices are per million tokens at each company's standard API rates. Meta priced Muse Wonder exactly like Claude Opus 5.5, cache rate included. Web search, when you turn on the web_search tool, adds $2.50 per 1,000 searches. Meta adds a little steering text of its own to every prompt, and those tokens aren't billed.

For a feel of real money: an agent that sends 30 million input tokens a month, 70% of them from cache, and writes 3 million output tokens costs $100.20 on Muse Wonder or Opus 5.5, $245.25 on Fable 5.1, $261.00 on GPT-6 Astra and $27.15 on Muse Spark 1.3. Output is the biggest line on every model, which is why reasoning effort matters so much.

Muse Code plans

Muse Code can be paid per token with your API key, or with a flat monthly plan. There are four plans: Everyday Usage (10 to 50 prompts every five hours), High Usage (5 times that), Power Usage (20 times, plus the strongest models, which means Muse Wonder Full) and Maximum Usage (80 times). Plan prices aren't published up front: you see what each plan includes when you subscribe, and benefits can vary by region. There's no free plan.

Read this before you subscribe: plans start in Contributor mode, which gives you more usage in exchange for letting Meta train future models on your prompts, code, files and the model's answers. You can switch it off in Muse Code's settings at any time, and you should before you open a client's repository. Pay-as-you-go API use of Muse Wonder is always Standard mode, where your content isn't used for training.

Is Muse Wonder better than Claude Opus 5.5? Meta's own numbers

Meta published one comparison table at launch, every model at maximum reasoning effort. The best score in each row is in bold:

Read it this way. Muse Wonder, including the plain version you can call from the API, leads on long-running software work (DeepSWE 78.8 against Opus 5.5's 74.2; SWE-Marathon 53.1 against 46.3), legal documents and remembering earlier context. Claude Opus 5.5 leads the broad Artificial Analysis Index (58 against 52 for the API model), writing a program from scratch (70.5 against 50.0), terminal coding and controlling a computer. Some rows are tests Meta built itself, and Meta ran some rival models in its own setup, so treat the table as a guide to what to try, not a verdict.

The practical test costs a few dollars: take twenty real tasks from your own work, run them through Muse Wonder and through what you use now, and compare. Because the price per token is identical to Opus 5.5, the answer comes down entirely to which model does your kind of work better.

Jake: "So which one wins for us?"

Ethan: "For the big refactor I've been putting off, Wonder looks strong. For small, quick fixes, I'll test both on the booking code before deciding."

Muse Code vs Claude Code: which should you use?

They're the same kind of tool: an agent in your terminal that reads your project, edits files and runs commands with your approval. The differences that actually matter:

Because Claude Code can run Muse Wonder too, you don't have to switch tools to try the model. Test the model first in the agent you know; switch agents only if you want Wonder Full or prefer how Muse Code works.

Rate limits, and what to do about 429 errors

Limits apply per team, not per key: every key on your team draws from the same budget. Muse Wonder allows 3,000 requests and 4,000,000 tokens per minute, and starting background responses is capped at 600 per minute. Over a limit you get HTTP 429 with rate_limit_exceeded and a Retry-After header. The OpenAI and Anthropic SDKs already retry 429s a couple of times with backoff; in your own loops, wait at least the Retry-After time, double the wait after each repeat, and add a little randomness so parallel workers don't retry in step. Every successful response also carries x-ratelimit-remaining-requests and x-ratelimit-remaining-tokens headers, so you can slow down before you hit the wall.

Muse Wonder and Muse Code errors, and the fix for each

command not found: 607358788850350

You exported the key without quotes, and the shell treated the pipe characters as commands. The variable is now empty. Run the export again with the key in double quotes, and fix the same line in ~/.zshrc if you saved it there.

Expressions are only allowed as the first element of a pipeline.

That's PowerShell's version of the quoting problem. Put the key in double quotes: $env:MODEL_API_KEY = "LLM|...|...".

Missing credentials. Please pass an `api_key`...

The OpenAI SDK found no key. Either MODEL_API_KEY is empty (often the quoting problem above) or you relied on the SDK to read it by itself. Pass api_key=os.environ["MODEL_API_KEY"] when you create the client.

401 Unauthorized, "type": "authentication_error", "code": "invalid_api_key"

The key is missing, wrong, deleted, or sent in the wrong header. A real key starts with LLM| and contains two pipe characters; check for stray spaces or a cut-off copy. In Claude Code or the Anthropic SDK, use ANTHROPIC_AUTH_TOKEN or auth_token=, never the api_key versions.

402 "billing_error", "code": "billing_not_configured"

The key works but your team has no working payment method. A team admin adds one under Billing in the dashboard; nothing else will fix it.

403 Forbidden

Your key doesn't have access to that model or feature, often because of team restrictions. Check the key's permissions in the dashboard, and remember that Muse Wonder Full isn't available on the API at all.

404 "model_not_found": The model `...` does not exist or is not available

The model ID is wrong. It's exactly muse-wonder-1.0, lowercase. Also check for a trailing slash: the base URL is https://api.meta.ai/v1 for OpenAI-style tools and https://api.meta.ai for Anthropic-style ones. GET /v1/models lists what your team can use.

400 when reasoning effort is "none"

Muse Wonder and Muse Spark always reason, so none is refused. The lowest setting is minimal.

You passed ... input tokens and requested ... output tokens. However, the model's context length is only 1048576 tokens

Your input plus the requested output doesn't fit the 1,048,576-token window. Trim old conversation turns, summarize, or lower the output limit.

429 "rate_limit_exceeded"

Your team went over a per-minute limit. Wait at least the Retry-After time and back off, and remember all your team's keys share the same limit.

malformed settings file

You created ~/.config/muse/settings.json without "schema_version": 1. Add that line, or delete the file and let Muse Code use its defaults.

muse: command not found right after installing

The installer updated your startup file, but your current terminal hasn't read it. Open a new terminal, or run source ~/.zshrc on Kali (source ~/.bashrc with bash). On Windows, open a new PowerShell window.

unsupported platform, or "the download was refused (HTTP 403)" during install

The first means your system isn't one of the supported ones (64-bit Intel/AMD or ARM64 Linux, macOS, or Windows). The second means the download server refused your sign-in; sign in with the Meta account you use for the Model API dashboard, and check that Meta offers the service in your country, since availability varies by country.

Claude Code works for chat but Plan Mode or subagents fail

One of the model aliases still names a Claude model. Set ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL and CLAUDE_CODE_SUBAGENT_MODEL to a Muse model too.

OpenCode says it can't see images, or loses track in long tasks

You're probably on the @ai-sdk/openai-compatible adapter or missing the modalities list. Switch to @ai-sdk/openai with the include: ["reasoning.encrypted_content"] option and the full input list shown above, then restart OpenCode.

Can you run Muse Wonder locally, fully offline?

No. Muse Wonder and Wonder Full are closed models: Meta hasn't released their weights and keeps them under a weight-security program, so every route on this page sends your prompts to Meta's servers. If your work has to stay on your own machine, Meta's open-weight model is Muse Glimmer, distilled from Muse Spark, which you download and run with tools such as llama.cpp, vLLM, Ollama or LM Studio. It won't match Wonder, but it's private and works without internet. Our Muse Glimmer local install guide covers Windows 11, Mac and Kali Linux and the memory you'll need.

Muse Wonder: frequently asked questions

By the evening, Ethan had Muse Wonder running three ways: Muse Code on the Kali laptop (after switching it off Muse Spark 1.2), Claude Code on the shop's Windows PC with every alias pointed at Muse Wonder, and a small Lambda function that drafts replies to booking questions, its key locked in Secrets Manager. He kept Claude Opus 5.5 for the quick fixes and gave Muse Wonder the refactor he'd been putting off for a month. Jake asked whether it was worth it. Ethan showed him the first week's bill and wrote the line below on the back of a repair ticket.

Revision note. Written October 13, 2026, for everyone who got a "can we use this?" message this week. "Measure twice, cut once," says the old proverb; check which model is answering before you judge it.