Muse Code
Use Meta's terminal coding agent to plan, write, test, and verify code across large repositories with persistent parallel agents and resumable task logs.
Muse Code Resources
Everything you need to install, run, price, and master Muse Code as a terminal AI coding agent
Muse Code Beginner Guide and Installation
Set up the terminal-based coding agent on macOS or Linux, connect billing, and complete a small repository task.
Muse Code is a terminal-first AI coding agent powered by Muse Spark 1.2. It works inside a local project directory, reads the repository context, edits files, runs development tools, and keeps a visible record of its work.
Check the Requirements
Use a supported macOS or Linux computer with a terminal, Git, and access to the project you want Muse Code to edit.
git --versionThe terminal prints the installed Git version.
Run the One-Line Installer
Open the Muse Code product page, copy its official one-line installation command, and run that command in Terminal. The installer adds the Muse Code CLI to your command path.
Run the official installation command shown on the Muse Code pageThe Muse Code executable becomes available in new terminal sessions.
Confirm the CLI Is Available
Open a new terminal window and display the built-in help screen before entering a project.
muse --helpMuse Code displays its available commands, options, and session controls.
Sign In to Your Meta Account
Start Muse Code and follow the terminal sign-in flow. Complete authentication in the browser when the CLI provides an authorization link.
museThe terminal confirms that the account is connected.
Configure API Billing
Connect an active Meta Model API billing account before running paid Muse Spark 1.2 requests. Usage is charged according to the number of input, cached-input, and output tokens processed.
Open the billing link provided during setupThe account is ready to run Muse Code sessions.
Open a Project Directory
Move into the repository before starting the agent so Muse Code can use the correct files, Git history, configuration, and project instructions.
cd ~/projects/my-app && git statusGit displays the active branch and working-tree status.
Start the First Session
Launch Muse Code from the repository root and give it a small, specific task that can be reviewed quickly.
museFind the failing unit test, explain the cause, make the smallest safe fix, and run the relevant tests.Muse Code inspects the repository, proposes or performs changes, and reports validation results.
Review Before Committing
Inspect every changed file and run the project's normal checks before creating a commit.
git diff && git statusYou can verify the final patch and confirm that no unrelated files were changed.
Muse Code Commands and CLI Reference
Use these terminal workflows to start tasks, plan changes, review patches, validate code, and continue previous work.
Run Muse Code from the root of a Git repository whenever possible. Clear prompts should define the goal, limits, validation command, and expected result before the agent begins editing.
Display CLI Help
Shows the commands and options available in the installed Muse Code version.
muse --helpStart an Interactive Session
Opens Muse Code in the current project directory and starts an interactive coding session.
cd ~/projects/storefront
museStart With a Direct Task
Starts a focused session with the initial task supplied from the terminal.
muse "Add server-side validation to the signup form and run the related tests."Request a Plan Before Editing
Keeps the first phase read-only while Muse Code identifies relevant files, dependencies, risks, and validation steps.
Plan the change first. List the files you expect to edit and wait before applying the patch.Limit the Working Scope
Prevents a focused task from expanding into unrelated files or broad refactoring.
Only edit src/auth and tests/auth. Do not change the database schema.Review Existing Changes
Asks Muse Code to inspect changed files for bugs, regressions, missing tests, and unsafe assumptions.
Review the current Git diff. Prioritize runtime bugs and security issues, then suggest the smallest fixes.Validate the Patch
Directs Muse Code to execute the project's formatter, type checker, tests, or build command after editing.
Run npm run lint, npm run typecheck, and the tests related to the files you changed.Inspect Changes Manually
Displays the patch created during the session so it can be reviewed before committing.
git diff --stat
git diffCheck Repository Status
Lists modified, deleted, untracked, and staged files after an agent task.
git status --shortResume Previous Work
Reopens saved task context so work can continue without rebuilding the entire conversation from the beginning.
Select the previous session from Muse Code's session-resume control.Delegate a Background Task
Moves a longer operation to a persistent agent while the main terminal session remains available for other work.
Run the full test-suite investigation as a background task and report the failing groups separately.Request a Final Summary
Produces a concise report covering edited files, behavior changes, validation results, and remaining follow-up work.
Summarize the files changed, tests run, unresolved issues, and any manual verification I should perform.Muse Code Background Agents and Multi-Agent Workflows
Delegate long-running engineering work to background agents while keeping progress, changes, and validation visible.
Muse Code can divide larger software-engineering tasks across persistent agents and parallel workers. The main session remains the control point for reviewing activity, resolving conflicts, inspecting results, and approving final changes.
- Suitable for repository-wide analysis, large test suites, migrations, dependency upgrades, and multi-stage debugging.
- The task retains its working context while the developer continues using the main terminal.
- Progress and completion information remain available through the agent activity view.
Supervision: Give each background task a narrow goal, allowed file scope, validation command, and clear stopping condition.
Muse Code Pricing and Token Costs
Estimate Muse Spark 1.2 costs for quick fixes, feature development, repository analysis, and persistent agent sessions.
Muse Code usage is billed through the Meta Model API. Input tokens cover prompts and repository context, cached-input tokens cover reused context, and output tokens cover generated explanations, plans, code, and tool responses.
| Category | Rate |
|---|---|
| Standard PricingInput Tokens | $1.25 |
| Standard PricingCached-Input Tokens | Discounted cached-input rate |
| Standard PricingOutput Tokens | $4.25 |
| Contributor PricingDiscounted Contributor Tier | Reduced token rates |
| Cost ExampleSmall Bug Fix | $0.21 |
| Cost ExampleFeature Development | $1.05 |
| Cost ExampleRepository Analysis | $3.78 |
| Cost ExampleLong-Running Agent Session | $16.75 |
| Cost ControlReuse Cached Context | Lower repeated-input cost |
| Cost ControlLimit Agent Scope | Reduces input and output usage |
Rates reflect standard Muse Code launch pricing. Cached-input and contributor-tier rates are billed separately through the Meta Model API.
Muse Code Model: Muse Spark 1.2 Specs and Benchmarks
Explore the coding model behind Muse Code, including repository context, tool execution, instruction following, and coordinated agent workflows.
Muse Spark 1.2 is a coding-focused model designed to work as an active software-development agent. Instead of only generating code snippets, it can inspect project context, plan multi-file changes, use development tools, execute validation commands, and coordinate parallel coding tasks.
Model Specifications
| Feature | Value |
|---|---|
| Primary purpose | Agentic software development |
| Project context | Repository-aware context handling |
| Tool use | Terminal and development-tool execution |
| Instruction following | Constraint-aware task execution |
| Multi-file reasoning | Cross-file implementation support |
| Agent coordination | Parallel and persistent agent workflows |
Evaluation Areas
| Feature | Value |
|---|---|
| Repository issue resolution | End-to-end coding performance |
| Tool-use accuracy | Correct command and tool selection |
| Instruction adherence | Requirement compliance |
| Code validation | Build and test completion |
| Long-horizon execution | Multi-step task completion |
| Multi-agent coordination | Parallel task consistency |
Muse Code vs Claude Code vs OpenAI Codex
Compare the three coding agents across terminal workflows, billing, background execution, parallel tasks, operating-system support, and model access.
Muse Code, Claude Code, and OpenAI Codex all help developers inspect repositories, modify code, and validate changes. Their main differences are how tasks are launched, where agents run, how long work can continue, which models are available, and how usage is billed.
Takeaway: Muse Code and Claude Code emphasize direct work inside a local project terminal, while Codex can support both interactive and delegated coding workflows.
Takeaway: Model selection, reasoning behavior, context use, and tool execution vary between providers.
Takeaway: All three cover the core coding-agent loop, but command controls and session management differ.
Takeaway: Muse Code places persistent agents near the center of its product positioning.
Takeaway: Compare conflict handling, task isolation, branch strategy, and final merge quality on a real repository.
Takeaway: Total cost depends on repository size, prompt length, generated output, command retries, and task duration.
Takeaway: Muse Code installation requirements should be checked before selecting it for Windows-centered teams.
Takeaway: Review permission prompts, sandbox behavior, network access, and secret-file exposure.
Takeaway: Teams should compare coding quality, latency, context handling, tool consistency, and cost using the same tasks.
Takeaway: Use identical bug fixes, feature requests, tests, restrictions, and validation commands for a useful comparison.
Muse Code Prompts and Coding Use Cases
Use structured prompts for debugging, features, refactoring, tests, reviews, migrations, documentation, and repository exploration.
Reliable Muse Code prompts should identify the project area, state the required result, define acceptance criteria, provide validation commands, and list restrictions. The templates below are designed to be copied into a project session and customized with repository-specific details.
Debug a Reproducible Bug
Investigate and fix the following bug in this repository.
Bug: [describe the incorrect behavior]
Expected behavior: [describe the correct behavior]
Reproductio…Build a New Feature
Implement the following feature in this project.
Feature: [feature description]
Target users: [user type]
Relevant area: [directory, service, page, or componen…Refactor Without Behavior Changes
Refactor [file, class, function, or module] to improve readability and maintainability without changing observable behavior.
Goals:
- Reduce duplication.
- Sim…Add Missing Test Coverage
Review [target files or module] and add focused automated tests for important behavior that is currently untested.
Cover:
- Normal success paths.
- Boundary va…Review a Pending Change
Review the current uncommitted changes and identify correctness, security, performance, maintainability, and testing issues.
Review priorities:
1. Bugs or beha…Migrate a Dependency or Framework
Migrate this project from [current dependency or version] to [target dependency or version].
First inspect:
- Package and lock files.
- Configuration files.
-…Create Developer Documentation
Create or update developer documentation for [feature, service, API, or workflow].
Audience: [new contributors, application developers, operators, or end users…Explore an Unfamiliar Repository
Analyze this repository and create a concise technical map for a developer who is new to the project.
Explain:
- The application's purpose.
- Main entry points…Muse Code Security, Troubleshooting, and Update Log
Protect sensitive project data, control terminal actions, recover failed sessions, and follow important Muse Code product changes.
Muse Code can inspect files, modify source code, and execute development commands, so projects should use clear permission rules and version-control safeguards. The troubleshooting entries below cover common setup, authentication, command, session, and platform problems, followed by a dated product update log.
Official Muse Code Resources
Follow Meta's official channels for setup, releases, and model updates.