Muse Code from Meta: How an AI Agent is Changing Software Development

Meta is developing its own AI tool for developers — Muse Code. Unlike typical code-writing assistants, it can work with large repositories, plan changes, write code, and verify the results. We explain how Muse Code works and what changes in the approach to software development.

What is Muse Code

Muse Code is an AI agent for programming that operates directly in the terminal. The developer describes the task in plain language, after which the agent analyzes the project, plans changes, edits files, and verifies the result.

Meta positions Muse Code as a tool for executing complex tasks in large repositories. It can plan changes, write code, and validate results, as well as coordinate multiple background agents working on different parts of the task.

Thus, the core idea of Muse Code is not about automatically writing individual lines of code, but rather transitioning to an agentic workflow — a process where AI participates in multiple stages of development simultaneously.

How Agentic Workflow Works

In a traditional scenario, the developer breaks down the task into stages themselves: studying the codebase, determining necessary changes, writing code, running tests, and fixing errors.

An AI agent can take over a significant portion of this sequence.

Muse Code operates roughly as follows:

1. Analyzes the task and codebase. The agent receives project context and determines which files and components need to be changed.
2. Forms a plan. Instead of immediately generating code, it breaks down a large task into individual actions.
3. Writes and modifies code. Muse Code can work with multiple files simultaneously and execute commands in the terminal.
4. Verifies the result. The agent runs necessary checks and analyzes the outcome.
5. Continues working. If needed, it can make additional changes to bring the task to a working state.

This sequence is what distinguishes a coding agent from a standard AI assistant.

Multiple AI Agents Instead of One

One of Muse Code's features is the ability to use persistent background agents, meaning background agents that remain active within a session.

Such agents help gather information and perform individual tasks in parallel with the main agent. This allows distributing complex work across multiple processes instead of executing each step sequentially.

This approach is especially important for large projects. For example, one task might simultaneously require backend changes, test updates, and verification of individual components. AI agents can work on these parts in parallel, after which the developer reviews the results.

Muse Spark as the Foundation of Muse Code

Muse Code works alongside Muse Spark — Meta's model optimized for programming and agentic tasks.

Muse Spark 1.2 improves code generation, debugging, codebase understanding, and execution of complex developer workflows. The model and Muse Code were trained jointly to better work together.

In September, Meta also introduced Muse Spark 1.3, an updated version of the model with improvements in coding and long-running agentic tasks. Currently, Muse Spark is used in Muse Code and is available via the Meta Model API.

What This Means for Developers

The emergence of such tools is gradually changing the role of developers. If previously a significant portion of time was spent directly on writing and fixing code, AI agents now allow developers to spend more time on architecture, task definition, and result verification.

However, autonomy does not mean a lack of control.

The more access an AI agent has to the repository and development tools, the more important code reviews, testing, access rights, and change control become. An agent's error in a small function and an error in an architectural decision can have vastly different costs.

Therefore, the most realistic development scenario is not "AI writes all the code instead of humans," but rather humans manage AI agents and verify their work.