Getting Started with the Terminal Coding Agent

Meta Muse Code: Getting Started with the Terminal Coding Agent

SitePoint TeamPublished inAI·Programming·
August 15, 2026

The AI briefing for Developers

Stay up to date with AI tools, model releases, and developer workflows that matter.

Weekly. Free. One click to leave.

SitePoint Premium
Stay Relevant and Grow Your Career in Tech

• Premium Results
• Publish articles on SitePoint
• Daily curated jobs
• Learning Paths
• Discounts to dev tools

7 Day Free Trial. Cancel Anytime.

Editorial Note: The commands and product details in this article have not been independently verified against a publicly released version of Muse Code. Verify all installation steps against official Meta AI documentation before following.

How to Get Started with Meta Muse Code

1. Install Node.js 18+ and ensure Git is configured on macOS, Linux, or Windows (WSL2).
2. Runnpm install -g @meta-ai/muse-code@0.1.0 --ignore-scripts to install the CLI globally.
3. Authenticate with muse-code auth and complete the OAuth browser flow using your Meta account.
4. Harden credential permissions with chmod 700 ~/.muse-code/ and chmod 600 ~/.muse-code/credentials.json.
5. Configure~/.muse-code/config.json with permission controls, sandbox rules, and deny paths for secrets.
6. Create a .museignore file and a MUSE_CODE.md custom instructions file in your project root.
7. Launch the REPL with muse-code inside your repo and submit your first scaffold prompt.
8. Commit a Git checkpoint before each agentic session, then iterate using the plan-edit-run-verify loop.

Terminal-based AI coding agents are a growing category in AI-assisted development. By the end of this article, readers will have installed Muse Code, configured it for a real project, executed common agentic coding tasks, and gained a working understanding of how it fits alongside alternatives.

Table of Contents

Why Meta Muse Code Matters Right Now

Terminal-based AI coding agents are a growing category in AI-assisted development. Tools like Claude Code, OpenAI’s Codex CLI, Gemini CLI, and Aider have demonstrated that developers increasingly prefer agentic workflows that operate directly in the terminal, reading and writing files, executing shell commands, and reasoning across entire codebases without switching to a separate IDE plugin. Meta’s entry into this space with Muse Code — announced in 2025 (verify current availability at the official Meta AI documentation site) — signals the company’s intent to compete directly in AI developer tooling.

Muse Code is Meta’s first standalone terminal coding agent, powered by the purpose-built Muse Spark model. It ships with no usage fees during the current rollout period, an open-source CLI client, and hosted inference — so there is no local GPU requirement. Pricing terms are subject to change; verify current terms at the official Meta AI pricing page before relying on free access. For developers already evaluating or using competing tools, this represents a meaningful alternative worth testing.

What Is Meta Muse Code?

Architecture and the Muse Spark Model

Muse Code is a command-line interface tool that provides agentic coding capabilities through Meta’s hosted API. Meta designed the underlying model, Muse Spark, for code-centric agentic workflows. It supports reading and writing files across a project, executing arbitrary shell commands, and performing multi-file reasoning and refactoring operations. Model name and version require confirmation from official Meta AI model documentation.

Because Muse Code runs against Meta’s hosted infrastructure, there is no requirement for local GPU hardware. The CLI client itself is lightweight, handling prompt submission, response streaming, permission management, and file operations locally while the model inference happens server-side.

How It Differs from Claude Code and Codex CLI

Muse Code occupies the same product category as Claude Code and Codex CLI. The pricing model is the most immediate distinction: Muse Code is currently free during its rollout period, while Claude Code pricing varies by access method (consult anthropic.com/claude-code for current terms) and Codex CLI consumes OpenAI API credits (consult platform.openai.com/docs for current pricing). The model lineage differs as well, with Muse Spark serving a different foundation than the models powering Claude Code or Codex CLI. Meta says the CLI client is open source (repository URL: verify and insert URL from official Meta AI documentation before use). The permission and sandboxing approach has its own design philosophy, covered in detail below. A thorough head-to-head comparison is outside this article’s scope; the focus here is on getting productive with Muse Code quickly.

Muse Code is Meta’s first standalone terminal coding agent, powered by the purpose-built Muse Spark model. It ships with no usage fees during the current rollout period, an open-requirement

Prerequisites

Before installing Muse Code, ensure the following are in place:

• Operating system: macOS 12 or later, or Linux (Ubuntu 20.04+, Debian, or Fedora). Muse Code runs on Windows through WSL2. WSL2 requires Windows 10 version 2004+ or Windows 11, with virtualization enabled in BIOS and the WSL2 feature activated via wsl --install.
• Node.js: Version 18 or later. Node.js 20 LTS is recommended.
• Meta account: A free Meta account with API access enabled.
• Git: Installed and configured.
• Terminal familiarity: This is intermediate-level content. Readers should be comfortable working in the filesystem and running CLI tools.

Installing Muse Code on macOS and Linux

Note: Verify the package name and installation method against the official Muse Code documentation before running these commands. Package names and installation methods shown below reflect the expected configuration but have not been independently confirmed against a live registry.

macOS Installation

The primary installation method uses npm to install Muse Code globally. Pin the version and skip lifecycle scripts to reduce supply-chain risk:

npminstall-g @meta-ai/muse-code@0.1.0 --ignore-scripts

For developers who prefer Homebrew (verify the formula exists with brew info muse-code before installing):

brew install muse-code

After installation, verify that the CLI is available and check the installed version:

npm list -g @meta-ai/muse-codemuse-code --version

This should output the current version number, confirming the binary is on the system PATH.

Linux Installation

On Debian and Ubuntu systems, ensure build tooling is present before installation, as some native dependencies may require compilation:

sudoapt-get updatesudoapt-getinstall-y --no-install-recommends build-essentialnpminstall-g @meta-ai/muse-code@0.1.0 --ignore-scripts

npm list -g @meta-ai/muse-codemuse-code --version

On Fedora, use the following command instead of build-essential if native compilation issues arise:

sudo dnf groupinstall "Development Tools"

Windows

Muse Code is compatible with Windows through WSL2. Developers should install a supported Linux distribution (Ubuntu 20.04+ is the safest choice) within WSL2 and follow the Linux installation instructions above. To confirm the WSL2 environment is ready:

wsl --list--verbose

Ensure the target distribution shows “VERSION 2” in the output before proceeding. If the VERSION column shows 1, upgrade with:

wsl --set-version Ubuntu 2

Authentication and Initial Configuration

After installation, the next step is authenticating with Meta’s API. Run the authentication command:

muse-code auth

This initiates an OAuth browser flow. The terminal will display output similar to:

Opening browser for Meta authentication...If the browser doesn't open, visit: https://auth.meta.ai/device?code=XXXX-XXXXWaiting for authentication...✓ Authenticated successfully. Credentials stored in ~/.muse-code/credentials.json

The authentication URL and credential storage path shown above are illustrative. Exact paths and URLs may differ; consult muse-code --help or official documentation for your installed version. After authentication completes, clear your terminal history to avoid leaving the device code in your shell history.

Muse Code stores credentials locally in the ~/.muse-code/ directory. Immediately after authentication, harden the permissions on the credential file and its parent directory:

chmod700 ~/.muse-code/chmod600 ~/.muse-code/credentials.json

This directory also holds the configuration file, which controls Muse Code’s behavior.

The default configuration file at ~/.muse-code/config.json supports several key settings. The following is a hardened starting configuration:

{"model":"muse-spark-1.2","permissions":{"file_write":"ask","shell_execute":"ask","file_read":"ask"},"context":{"max_files":200,"max_file_size_kb":512,"auto_index":true,"deny_paths":[".env",".env.*","**/.env","**/.env.*","~/.ssh/","~/.aws/","**/*.pem","**/*.key"]},"shell":{"sandbox":true,"allowed_commands":["npm","node","git","tsc"]},"session_log":"~/.muse-code/sessions/"}

The permissions block is worth attention. Setting file_write or shell_execute to "auto" enables the agent to proceed without confirmation, which speeds up workflows but reduces oversight. Never use auto-approve on production codebases; destructive shell commands (e.g., rm, database migrations) will execute without review. The file_read permission is set to "ask" rather than "auto" to prevent the agent from silently reading sensitive files such as .env, SSH keys, or cloud credential files. The deny_paths list provides an additional layer of protection by explicitly blocking known secret-bearing paths from the agent’s context. The sandbox flag restricts shell execution to explicitly allowed commands. Note that npx is intentionally excluded from the allowed commands list because it can fetch and execute arbitrary remote packages, effectively bypassing the sandbox. If you need npx for specific tools, create a wrapper script that invokes only the permitted command and allowlist that script instead. Adjust these values based on how much you trust the project environment.

Never use auto-approve on production codebases; destructive shell commands (e.g., rm, database migrations) will execute without review.

Your First Session: Scaffolding a Project

Launching Muse Code in a Repository

Navigate to a project directory and start Muse Code’s interactive REPL:

mkdir my-api &&cd my-apigit init --initial-branch=mainmuse-code

The REPL launches with status information about the session:

Muse Code v0.1.0Model: Muse Spark 1.2Context: 0 files indexed (empty project)Detected: New project (no package.json)Type your prompt or use /help for commands.>

The agent automatically detects the project type based on existing files. In an empty directory, it recognizes a fresh project and adjusts its behavior accordingly.

Giving Your First Prompt

With the REPL active, enter a natural language prompt describing what to build:

> Create an Express.js REST API with three endpoints: GET /users, POST /users, DELETE /users/:id. Use TypeScript, include input validation with Zod, and add basic error handling.

Muse Code responds with a structured plan before making any changes:

Plan:1. Initialize package.json with TypeScript and Express dependencies2. Create tsconfig.json with strict mode3. Create src/index.ts — Express server setup4. Create src/routes/users.ts — Route definitions5. Create src/schemas/user.ts — Zod validation schemas6. Create src/middleware/errorHandler.ts — Centralized error handling7. Create src/types/user.ts — TypeScript interfacesFiles to create: 7Dependencies: express, zod, typescript, ts-node, @types/expressProceed? [y/n/edit]

After approving with y, the agent creates the files and installs dependencies. The resulting file structure:

my-api/├── package.json├── tsconfig.json└── src/├── index.ts├── routes/│   └── users.ts├── schemas/│   └── user.ts├── middleware/│   └── errorHandler.ts└── types/└── user.ts

Understanding the Permission Model

Muse Code implements a three-tier permission system: read, write, and execute. File reads default to requiring approval in the hardened configuration above, ensuring the agent cannot silently ingest sensitive files. File writes and shell command execution also require explicit approval unless the configuration has been set to "auto".

This interactive approval flow means the developer sees exactly which files will be read, modified, and what commands will run before anything happens. Toggle auto-approve mode in config.json or at runtimeo, enable session logging (the session_log key in config.json) so that all permission mode changes and agent actions are recorded. For production codebases, keeping interactive approval active is strongly recommended

Core Workflow Commands and Patterns

File Editing and Multi-File Refactoring

One of Muse Code’s strongest capabilities is multi-file reasoning. Given the project scaffolded above, a refactoring prompt demonstrates this:

> Refactor the user routes into a separate controller file and add a service layer with an in-memory data store.

The agent analyzes the existing code, proposes a plan, and on approval, produces modifications:

Changes:Modified: src/routes/users.ts — Simplified to route definitions onlyCreated:  src/controllers/userController.ts — Request handling logicCreated:  src/services/userService.ts — Business logic with in-memory storeModified: src/types/user.ts — Added User interface with id fieldSummary: 2 files modified, 2 files created

Diffs for modified files appear inline, allowing review before the changes are written to disk.

Running Shell Commands Through the Agent

Muse Code can execute shell commands as part of its reasoning loop. This is particularly useful for test-driven workflows:

> Run the test suite and fix any failing tests.

The agent first executes the test command:

Executing: npmtest...FAIL src/__tests__/users.test.ts✗ POST /users should validate input (expected 400, received 500)1test failed. Analyzing failure...Proposed fix: Update errorHandler.ts to catch ZodError and return400 status.Apply fix? [y/n]

After approval, it modifies the error handler, reruns the tests, and confirms they pass. This plan, edit, run, verify, fix loop is the core agentic pattern.

Context Management

For large codebases, Muse Code indexes the file tree to build context. A .museignore file in the project root uses .gitignore-style pattern syntax (verify exact pattern support in official documentation), excluding directories like node_modules, dist, or large asset folders from indexing. Include secret-bearing file patterns to prevent them from being ingested into the agent’s context:

node_modules/dist/coverage/*.lock.env.env.*.env.local.env.*.local**/*.pem**/*.key**/*.p12**/*.pfx*.log

The REPL provides several slash commands for managing context:

• /add src/services/ adds specific files or directories to the active context.
• /context displays currently loaded files and token usage. Use /clear to reset the conversation context entirely.
• /cost shows token consumption for the session.
• /permissions [mode] changes the permission level (e.g., /permissions auto for auto-approve).

Using Custom Instructions

Project-level instruction files allow teams to encode coding standards and architectural preferences. Creating a MUSE_CODE.md file in the project root provides persistent instructions that the agent loads automatically at session start:

# Project Instructions- Use functional components and avoid classes- Prefer named exports over default exports- All error responses must follow the { error: string, code: number } shape- Use npm for package management

Custom instructions apply to future sessions and do not retroactively rewrite files created in prior sessions. If multiple team members prompt the agent differently, these shared instructions keep the output consistent.

Practical Example: Adding a Feature End to End

To illustrate the full agentic loop, consider adding JWT authentication middleware to the Express API built in previous sections:

> Add JWT authentication middleware. Protect the POST /users and DELETE /users/:id endpoints. The GET /users endpoint should remain public. Include a POST /auth/login endpoint that accepts email and password and returns a JWT. Use jsonwebtoken and bcrypt. Store the JWT secret in an environment variable (JWT_SECRET) and never commit it. Specify explicit bcrypt salt rounds (e.g., 12).

Plan:1. Install jsonwebtoken, bcrypt, and their type definitions2. Create src/middleware/auth.ts — JWT verification middleware3. Create src/routes/auth.ts — Login endpoint4. Create src/services/authService.ts — Token generation and password comparison5. Modify src/index.ts — Register auth routes6. Modify src/routes/users.ts — Apply auth middleware to POST and DELETE7. Modify src/services/userService.ts — Add password hashing on user creation8. Create src/__tests__/auth.test.ts — Integration testsProceed? [y/n]

After approval, Muse Code installs dependencies, creates and modifies the listed files, then runs the test suite to verify that the feature works. When tests fail, it diagnoses the issue and proposes a fix, continuing the loop until tests pass. Security note: After the agent generates the authentication code, review the output for hardcoded secrets. The JWT signing secret should be read from process.env.JWT_SECRET, and bcrypt hashing should use an explicit salt rounds parameter (e.g., bcrypt.hash(password, 12)) rather than relying on library defaults. Never commit secrets to version control.

This sequence — prompt, plan review, code generation, test, fix — is the loop you’ll repeat for most features.

Tips, Gotchas, and Best Practices

Keep prompts specific and scoped. Asking the agent to “rewrite everything” produces worse results than targeted, feature-level requests. Break large tasks into discrete steps: one prompt per logical unit of work.

Git is the ultimate safety net, so commit before major agent operations. Before any agentic session, confirm your .gitignore excludes secrets, then create a checkpoint:

cat .gitignore |grep-E'.env|.key|.pem'||echo"WARNING: .gitignore may not exclude secrets"gitadd-Agit statusgit commit -m"pre-agent checkpoint"

Review the output of git status before committing to ensure no secret files are staged.

Auto-approve mode is convenient for prototyping, but on production codebases you should review every diff before approving writes. A single unreviewed rm -rf or database migration can cause real damage.

Git is the ultimate safety net, so commit before major agent operations. A single unreviewed rm -rf or database migration can cause real damage.

During the free rollout period, expect rate limits. If you see HTTP 429 responses or the CLI warns about quota, pause and retry after the interval shown in the response headers. Session-heavy users should monitor token consumption with /cost and batch work into fewer, more focused prompts.

Muse Code supports fewer languages than Claude Code or Codex CLI at launch. Test with your primary language before committing to Muse Code for a project. The context window size is not publicly documented at time of writing; very large monorepos may exceed its limits. The tool ecosystem is early; there is no MCP (Model Context Protocol) support comparable to what Claude Code offers for external tool integrations.

Muse Code Getting Started Checklist

Use this checklist to confirm a complete setup:

• Meta account created and API access enabled
• Node.js 18+ installed (20 LTS recommended)
• Muse Code CLI installed globally via npm (version-pinned) or Homebrew
• Authentication completed (muse-code auth)
• Credential file permissions hardened (chmod 700 ~/.muse-code/, chmod 600 ~/.muse-code/credentials.json)
• Configuration file at ~/.muse-code/config.json reviewed and customized (verify file_read is not "auto", npx is not in allowed_commands, deny_paths includes .env patterns)
• .museignore configured to exclude large directories, lock files, and secret-bearing files (.env, *.pem, *.key)
• Project-level MUSE_CODE.md custom instructions file created
• First scaffold prompt executed and generated files reviewed
• Permission model understood (auto-approve vs. interactive mode)
• Git commit made before first agentic editing session (after verifying .gitignore)
• Shell command execution tested through the agent
• Multi-file refactoring tested and diffs reviewed
• End-to-end feature added and verified with passing tests

What’s Next for Muse Code

The following features have been discussed in community channels but are not officially confirmed as of publication; consult the official Muse Code changelog for current roadmap status. Potential directions include IDE integrations for editors like VS Code, support for MCP and tool-use protocols to enable external service integrations, expanded model options, and enterprise features for team-scale deployments.

Developers can follow updates through the Meta AI blog, the Muse Code GitHub repository, and the project’s changelog. As the tool matures through its rollout period, community feedback on edge cases, language support gaps, and workflow patterns will shape what gets built next. Filing issues against the CLI client is the most direct way to influence that development.

Sharing our passion for building incredible internet things.