Meta is pushing deeper into the increasingly crowded market for AI coding agents with the launch of Muse Code, a terminal-based software engineering assistant, and Muse Spark 1.2, the coding-focused model that powers it. The pitch is not simply that the system can write code, but that it can take on larger, messier jobs: understand a repository, map out a plan, make changes, run validation, recover from interruptions, and keep going without needing a developer to repeatedly point it in the right direction.

That framing matters. The AI coding conversation has moved well past autocomplete tools that suggest the next few lines in an editor. The new race is over agents: systems designed to use a terminal, inspect files, execute commands, test their own work, and work through multi-step engineering tasks. Meta is now entering that race with a product that looks deliberately built for long-running, repository-scale work rather than one-off code generation.

Muse Code is launching in beta for macOS and Linux, while Muse Spark 1.2 is also available through Meta Model API with broader global access.

A terminal agent built to persist

At first glance, Muse Code resembles the growing class of command-line coding agents popularized by tools such as Claude Code and OpenAI‘s Codex. Developers give it a task in the terminal, and the agent can investigate the codebase, edit files, invoke tools, and verify its output. Meta says the product is intended for complex engineering tasks across large repositories, including planning changes, writing the implementation, and validating the results.

The more unusual part is its architecture. Muse Code uses a main agent loop alongside persistent asynchronous background agents. Rather than creating a fresh helper agent for every individual step, those background agents remain active during the session, carrying context forward and deciding when to report back to the primary agent. Meta argues this should reduce duplicated investigation, latency, and the amount of manual steering required on difficult tasks.

In plain terms, it is an attempt to make the system feel less like a chatbot that forgets what it was doing every few minutes and more like a small, always-on engineering team. One process can keep examining a problem while another continues the main task. That is a useful direction for real-world development, where much of the work is not typing code but checking assumptions, reading unfamiliar files, reproducing a bug, and figuring out which of several plausible fixes is actually safe.

Meta has also designed Muse Code around a local event log. Every model call, tool execution, approval, and edit is recorded in a single history, which the company says makes sessions replay-exact and restart-safe. If a process crashes or stops, Muse Code is meant to resume from the precise point where it left off rather than restarting the task from scratch.

That feature may sound mundane, but it addresses a real friction point in agentic development. A coding task that takes hours can become unusable if the agent loses its place after a failed command, a session timeout, or a local machine hiccup. Long-running reliability is less flashy than benchmark scores, yet it is one of the things that will determine whether agents become everyday engineering tools or remain impressive demos.

The model behind it

Muse Spark 1.2 is a coding-oriented update to Muse Spark 1.1. Meta says it increased training compute for coding work and broadened the mix of training environments, with the stated goal of improving code generation, difficult debugging, codebase comprehension, and end-to-end developer workflows. The company also says the model retains strength in general agent tasks, not just programming.

The company trained the model alongside Muse Code, an approach often described as co-training a model with its “harness.” That is important because a coding model’s real performance depends heavily on the environment wrapped around it: what tools it can call, how it is instructed to plan, how it manages context, and how it verifies results. A strong model in a weak agent framework can still produce fragile outcomes. Meta says its training included examples from the Muse Code workflow, plus optimizations around goals, context compaction, and subagent behavior.

Meta is also emphasizing long-horizon tasks. According to the company, Muse Spark 1.2 was trained for whole-repository generation, end-to-end projects, and automated research-style work. It uses planning to sequence operations, goal conditioning to keep the task on track, and context compaction to retain the most relevant information as a session grows longer.

This is a direct response to one of the hardest problems in AI-assisted software engineering: maintaining coherence over time. Generating a function is easy compared with making changes across a large codebase without breaking naming conventions, interfaces, tests, dependencies, or product logic. The challenge is less about producing syntax and more about preserving an accurate working model of a project as the task evolves.

Benchmarks need context

Meta reports evaluations on Terminal-Bench 2.1, DeepSWE v1.1, GDPVal-AA v2, MCP Atlas, and its own internal coding benchmark. The reported coding tests cover practical terminal tasks and software engineering problems where an agent must produce working changes, not merely describe a solution.

For Terminal-Bench 2.1, Meta says it evaluated all 89 official tasks in isolated cloud sandboxes, measured task success over five attempts, and used executable verifiers to judge the resulting environment. DeepSWE v1.1, meanwhile, includes 113 tasks across 91 repositories and five languages – TypeScript, Go, Python, JavaScript, and Rust – with functional checks and regression tests used to evaluate final patches.

Those are meaningful tests because they better resemble actual development work than a static coding prompt. Still, there is a caveat that readers should keep in mind: benchmark comparisons among agents are rarely perfectly apples-to-apples. Meta says it tested each competing model with its selected agent product, rather than putting all models into one identical harness, and acknowledges that its setup may not represent the best possible performance of proprietary competitors in their own optimized environments.

That does not invalidate the results, but it does make the broader point: the agent and the model are now inseparable parts of the product. Developers should treat rankings as signals rather than final verdicts, then test the systems on the languages, repositories, security requirements, and workflows that actually matter to them.

The 24-hour stress test

Meta’s most striking example is a GPU kernel optimization experiment. The company says Muse Spark 1.2, working through Muse Code, was tested on iterative optimization tasks involving more than 1,000 tool calls and runs lasting up to 24 hours. The agent wrote code, compiled it, profiled performance, and repeatedly improved GPU kernels relative to a baseline implementation for NVIDIA Hopper hardware.

That is the kind of workload that highlights why persistent agents and restartable execution are central to Meta’s launch message. A system trying to optimize performance-sensitive code cannot stop after producing a plausible first answer. It has to test, measure, change one variable at a time, and recognize whether a modification actually improved the result.

Meta notes that the agents were prohibited from simply importing third-party kernel libraries, forcing them to implement the underlying algorithms in Triton and apply specialized optimization techniques themselves. It is an impressive use case, although it is still a controlled evaluation rather than proof that the agent can independently handle every high-stakes performance problem in production.

Why this launch matters

For Meta, Muse Code is also a strategic move. The company has spent years building major AI research capabilities, but the commercial developer tooling layer has been increasingly dominated by rivals offering polished coding agents, model APIs, and tightly integrated workflows. Launching a first-party terminal agent gives Meta a more visible way to connect its models to developers’ day-to-day work.

The bigger story is that software development is starting to be reshaped around delegation. Engineers will still decide what to build, set constraints, review architecture, and take responsibility for the final code. But the mechanics of implementation – exploring a repository, making repetitive edits, running tests, tracing a failure, and iterating on a patch – are becoming tasks that AI agents can increasingly share.

Muse Code’s beta status is worth taking seriously. The biggest unanswered questions will be practical ones: how dependable it is outside benchmarks, how much oversight it needs, how well it works in proprietary codebases, what it costs at scale, and how safely teams can give it access to tools and repositories. Meta has made a compelling case that it is targeting the right problems. The next test is whether developers find that the system saves time on ordinary work, not just spectacular technical demonstrations.