--- title: "Introducing Muse Code and Muse Spark 1.2" url: https://daily.dev/posts/introducing-muse-code-and-muse-spark-1-2-ecg30cus4 source_url: https://daily.dev/posts/introducing-muse-code-and-muse-spark-1-2-ecg30cus4 type: freeform source: "Andrew M" author: "Andrew M" published: 2026-08-06T18:01:52.748Z updated: 2026-08-06T18:02:27.240Z tags: ["llm", "ai-agents"] reading_time: 4 upvotes: 2 comments: 1 language: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Introducing Muse Code and Muse Spark 1.2 **[Andrew M](https://daily.dev/sources/dup6ye036hupdshygexyu)** · [@andrewma](https://daily.dev/andrewma) · 4 min read · 2 upvotes · 1 comments ## Summary Meta has released Muse Code (beta), a terminal-based coding agent powered by the new Muse Spark 1.2 model. Muse Code handles complex software engineering tasks across large repositories, using async background agents that persist throughout a session to reduce latency and redundant work. Its runtime uses a local event log for replay-exact, restart-safe execution. Bundled skills include /plan, /grill, and /goal commands. Muse Spark 1.2 was co-trained with Muse Code, with scaled-up compute on coding tasks, long-horizon training (whole-repo generation, auto-research), and a self-improvement loop using Muse Spark 1.1 to generate training data. A case study shows the model iteratively optimizing GPU kernels over 1,000+ tool calls across up to 24 hours, designing a two-kernel Triton pipeline for NVIDIA Hopper GPUs with MLA-specific optimizations. Muse Spark 1.2 is available in Muse Code and via the Meta Model API. ## Content We're excited to release Muse Code (beta), a terminal coding agent powered by Muse Spark 1.2, our newest model. This marks our next step toward the frontier, with larger and much more capable models on the way. ## **Install Muse Code on macOS or Linux:** `curl-fsSLhttps://dev.meta.ai/install.sh|bash`Copy installation command Muse Code takes on complex software engineering tasks across large repositories: planning changes, writing code, and validating the results. It can coordinate multiple persistent subagents for each task, solving difficult problems faster, more accurately, and with less intervention. ## **Muse Code** ### **Async Background Agents** Muse Code operates with a simple agent loop plus a set of async background agents to enhance the main agent's capability. These specialized background agents remain active throughout each session, rather than being spawned for individual tasks, helping avoid redundant information gathering. They carry out next steps and choose when to communicate back to the main agent. Their persistence reduces latency and the need for steering on difficult, multi-step tasks. ![image.png](https://media.daily.dev/image/upload/s--AIK8PqOc--/f_auto/v1786039046/ugc/content_8ab20146-78e6-4d4a-a8d5-c418c02c15f8?_a=BAMAMicg0) ![image.png](https://media.daily.dev/image/upload/s--4SfHeeYI--/f_auto/v1786039123/ugc/content_41153a23-3de5-4919-b8e5-3cf874d2cb02?_a=BAMAMicg0) ![image.png](https://media.daily.dev/image/upload/s--Ya5OOfyP--/f_auto/v1786039216/ugc/content_34d2631c-15c7-4f07-9be4-92896f982426?_a=BAMAMicg0) ### **Runtime Design** Muse Code uses a local event log in which every model call, tool run, approval, and edit is appended. This single source of truth makes the runtime replay-exact and restart-safe: after a crash, the agent can resume precisely where it stopped. That ability lets Muse Code take on long-running tasks without being derailed by failures. ### **Bundled Skills** Muse Code ships with several default skills. `/plan` turns a task into an approval-gated plan, `/grill` stress-tests that plan until it holds up, and `/goal` works toward successful completion of the specified objective. ## **Muse Spark 1.2** Muse Spark 1.2 is a coding-focused update to Muse Spark 1.1, with improvements in code generation, complex debugging, codebase understanding, and end-to-end developer workflows. In Muse Spark 1.2, we significantly scaled up training compute on coding tasks while expanding training environment diversity. The model also maintains its strength in other key areas like general agents. ![image.png](https://media.daily.dev/image/upload/s--Y3RcTA2e--/f_auto/v1786039255/ugc/content_4ac54e0c-23d4-4b8e-8eff-8851c49336b0?_a=BAMAMicg0) ![image.png](https://media.daily.dev/image/upload/s--gyBYfUra--/f_auto/v1786039257/ugc/content_dba69f09-38d6-486d-baa0-5a22f20097fe?_a=BAMAMicg0) ![image.png](https://media.daily.dev/image/upload/s--kDV2veVM--/f_auto/v1786039259/ugc/content_5822bb9d-08de-4768-905c-fdbd227b5c01?_a=BAMAMicg0) ### **Co-Training With Muse Code** We co-trained Muse Spark 1.2 with Muse Code to ensure the model exhibits its best performance and coding usability when paired together. The training included rejection sampled harness trajectories and recipe optimizations for goals, compaction, and subagents, alongside the integration of the Muse Code toolset to maximize harness compatibility. ### **Long-Horizon** Muse Spark 1.2 was extensively trained on long-horizon coding tasks, including whole-repository generation, large end-to-end projects, and auto-research. It leverages planning to sequence work, goal conditioning to maintain direction, and context compaction to retain the knowledge needed to sustain progress. ### **Self-Improvement** We also used Muse Spark 1.1 to generate challenging coding environments and instruction-following templates. The model then graded candidate solutions on how well they satisfied those requirements, producing a scalable training dataset for Muse Spark 1.2. This self-improvement loop helped Muse Spark 1.2 follow complex instructions more precisely than its predecessor. ## **Case Study: Kernel Optimization** We tested the model's ability to iteratively optimize GPU kernels over 1,000+ tool calls (up to 24 hours). Leveraging Muse Code's agentic coding environment, the model writes, compiles, profiles, and progressively improves kernel performance relative to a provided baseline implementation. We benchmarked on KDA and MLA kernels for NVIDIA Hopper GPUs. The agent continues to achieve substantial improvements over the provided baseline implementation. ![image.png](https://media.daily.dev/image/upload/s--19Mh83PH--/f_auto/v1786039286/ugc/content_bd5839e7-b7ae-4e2e-b409-a3f788885897?_a=BAMAMicg0) ![image.png](https://media.daily.dev/image/upload/s--SthyOV6U--/f_auto/v1786039299/ugc/content_08a24a16-b12b-43f0-8774-8aa9e344424b?_a=BAMAMicg0) We benchmark against a PyTorch reference implementation at batch size 1, number of heads 64, sequence length 8192, and latent dimension 512. Muse Spark 1.2 designed a two-kernel Triton pipeline for this workload, combining kernel fusion and tiling with MLA-specific optimizations such as reusing the shared KV latent as both K and V. ## **Availability** Muse Spark 1.2 is available today in Muse Code and in Meta Model API with expanded global access. We have a lot on the horizon, including new harness features and more powerful models. We can’t wait to see what you build! --- Tags: [#llm](https://daily.dev/tags/llm), [#ai-agents](https://daily.dev/tags/ai-agents) [View this post on daily.dev](https://daily.dev/posts/introducing-muse-code-and-muse-spark-1-2-ecg30cus4)