Meta launches Muse Code — still working at tool call 847

Muse Code can recover after a crash and work through 1,000 tool calls. The harder test starts when another engineer changes the repository.

My laptop will crash. Marco will change the repo while I’m making coffee. A useful coding agent needs to survive both. Meta launches Muse Code agent for sprawling software repositories, and the obvious comparison is Claude Code versus OpenAI Codex versus Meta’s shiny new terminal creature. We’ll get benchmark charts, tribal arguments on X and at least fourteen YouTube thumbnails featuring a shocked man pointing at a logo.

Fine. I care about the boring feature that keeps software alive: memory.

I need an agent that can work for six hours, survive my computer doing something idiotic and remember why it changed line 4,812 in a repository nobody fully understands anymore. Another AI that can generate a React component has limited charm. My espresso machine will probably manage that by Christmas.

I’ve spent 20 years running Ad Astrum and shipping products across mobile, machine learning and IoT. With ALYT, I lived through hub hardware, mobile software and cloud services. I also built a connected espresso machine for Pascucci, which taught me that coffee can generate distributed-systems problems once you attach enough telemetry to it.

Failures gather at the seams. A process loses state. Somebody changes an assumption halfway through. A tool retries work it already completed. The code itself is often the easy bit, which is emotionally inconvenient for engineers hoping every problem can be solved with a more elegant function.

Muse Code keeps a local event log. Meta is treating an AI coder like a long-running software worker whose memory needs durability.

Finally. Database thinking has entered the chatbot casino.

The smartest intern alive still needs a shift log

Every old codebase contains decisions whose authors have left, tests that pass during a full moon and a utility named `finalNewParserV2` that everyone fears deleting.

I describe inherited repositories as trattorias where every cousin rewired the kitchen. The oven works. The lights flicker when someone uses the slicer. Nobody will explain why the freezer has its own router.

Generating another function barely touches this problem. Repository-scale work depends on remembering why an earlier decision was made, which command already ran, what a human approved and which suspicious edit still needs verification.

Meta describes Muse Code’s scope in its August 5, 2026 launch post:

Muse Code takes on complex software engineering tasks across large repositories: planning changes, writing code, and validating the results.

That part sounds standard for a coding agent in 2026. The runtime architecture is much more interesting.

Muse Code uses a local append-only event log. Every model call, tool run, approval and edit goes into it. Meta calls the runtime “replay-exact” and “restart-safe,” so an interrupted task can resume precisely where it stopped.

Meta’s research team explains it directly:

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.

I read that and thought: write-ahead log.

A database records an operation durably before treating the work as committed. When the server falls over, the system can reconstruct what happened without entering existential therapy. Muse Code applies the same operational instinct to an agent’s activity history. The implementation may differ from a database WAL, but the idea is familiar: preserve enough ordered state to recover the process.

That beats throwing another hundred thousand tokens at the problem. A large context window gives the model more material during one inference. A durable log carries history across interruptions.

Muse Code also has persistent asynchronous background agents. They stay active for the session instead of being recreated for each task, which should reduce repeated repository exploration and spare us the ritual where every new subagent spends five minutes rediscovering `package.json`.

Meta’s August 5 post says:

These specialized background agents remain active throughout each session, rather than being spawned for individual tasks, helping avoid redundant information gathering.

The architecture gives context a lifecycle. Background workers can hold task-specific knowledge and report to the main agent when useful. Stuffing the whole repository into a fresh prompt every few minutes starts to resemble emailing yourself database backups.

Muse Code is currently a terminal-only beta for macOS and Linux. It ships with `/plan`, which creates an approval-gated plan; `/grill`, which stress-tests that plan; and `/goal`, which pursues a specified objective.

`/grill` is perfect. Every architecture plan deserves the same treatment as vegetables at an Italian family barbecue: aggressive heat, several opinions, one uncle insisting everything worked better in 1997.

Meta trained the model inside its own workshop

Muse Spark 1.2 was co-trained with the Muse Code harness. I’d take that pairing over a lonely benchmark score because coding-agent performance now depends heavily on the runtime around the model.

Meta included rejection-sampled harness trajectories in training. It optimized the model around goals, context compaction and subagent behaviour. Muse Code’s tools were part of that process from the beginning, instead of arriving after training like an aftermarket stereo.

Meta says:

We co-trained Muse Spark 1.2 with Muse Code to ensure the model exhibits its best performance and coding usability when paired together.

I’ve hired brilliant developers who needed time to learn the company’s scripts and deployment habits. Give a strong engineer a random laptop and unfamiliar tools, then measure output on day one. Congratulations, you have benchmarked onboarding.

The same logic applies here. A slightly weaker model trained around its tools and failure modes can beat a theoretically smarter model shoved into a generic agent loop. The harness controls which files appear, how tool calls work, what survives compaction and when a subagent reports back.

Muse Spark 1.2’s training included whole-repository generation, large end-to-end projects and automated research. Meta used planning and goal conditioning to keep long tasks pointed in the right direction. Context compaction retained selected knowledge without dragging every historical token forward forever.

The previous Muse Spark 1.1 model helped produce the next training set. According to Meta and MarkTechPost, Spark 1.1 generated difficult coding environments plus instruction templates, then graded candidate solutions against those requirements.

Yes, the model helped write the exam and mark the papers. I share your facial expression.

Synthetic environment generation can still produce edge cases that humans would never have the patience to author at scale, provided external verification keeps the marking honest.

I was dismissive of long-horizon agent demos. Many boil down to “we left it running overnight and it generated 40,000 lines.” I’ve generated 40,000 bad lines without AI. Volume has never impressed me.

Meta’s GPU-kernel case study changed my mind a little.

The company ran Muse Code for more than 1,000 tool calls across sessions lasting up to 24 hours. The agent wrote code, compiled it and profiled performance while repeatedly modifying KDA and MLA kernels for NVIDIA Hopper GPUs.

Meta’s researchers state:

We tested the model's ability to iteratively optimize GPU kernels over 1,000+ tool calls (up to 24 hours).

Third-party kernel libraries were prohibited. Muse Spark 1.2 had to implement the optimizations in Triton instead of wrapping an existing FLA implementation and taking an early lunch.

For KDA, it produced a chunk-parallel preparation kernel followed by a sequential inter-chunk scan. For MLA, it built a two-kernel Triton pipeline that reused the shared KV latent as both K and V. Meta’s published reference setup used batch size 1, 64 heads, a sequence length of 8,192 and a latent dimension of 512.

That is serious work. Kernel optimization requires repeated compilation and profiling, with correction after correction. One locally clever edit can slow the wider workload. An agent still operating coherently at tool call 847 tells me more than a perfect answer to a self-contained Python puzzle.

Meta also showed Muse Code consuming an MP4 fly-through of a home and producing a vacation-home marketing and booking site. Cute. The villa website gets the retweets; tool call 847 gets my credit card.

A screenshot showcasing Meta's Muse Code interface, highlighting its features and user-friendly design for developers.

Alt text: Muse Code persistent agents and event log operating inside a sprawling software repository

A 24-hour demo is easier than Tuesday with three engineers

Muse Code can remember its own actions after a crash. Then another engineer opens the repository.

On August 3, 2026, two days before Meta announced Muse Code, Yuqiao Tan, Jinxiang Meng, Fangyu Lei and four co-authors submitted SWE-Touch: Benchmarking Coding Agents When Users Touch the Code to arXiv. Their framework tests agents inside workspaces where a user changes task-relevant code while the agent is still working.

The researchers evaluated nine coding models. SWE-Touch injects validated “Counter-Edits,” meaning plausible human changes that conflict with successful completion of the assigned task.

Their result belongs on every coding-agent product manager’s monitor:

Counter-Edit lowers average resolve rate by 7.7 percentage points on SWE-bench Verified, with degradation also persisting on both longer-horizon benchmarks.

Those longer-horizon experiments covered SWE-Bench Pro and DeepSWE. Agents sometimes retained conflicting code. Others replaced the human edit without properly reinspecting the repository or skipped targeted tests around the modified behaviour.

A local event log answers one question: “What did my agent do?” Workspace awareness has to answer another: “What changed outside the agent’s actions?”

An agent can possess a perfect replay of its own history while carrying a stale model of the repository. Persistent subagents could preserve those stale assumptions with impressive efficiency. Darkly funny. Also expensive.

Muse Code may remember exactly where it was when the terminal crashed. I want to know whether it notices that Marco rewrote the function while it was gone.

I’ve felt this from the human side. Across ALYT, Life Control for Megafon and EON’s home-automation platform, the worst bugs appeared when separate components held different beliefs about the system. A sensor believed one event had occurred. The mobile app believed another. The cloud had received half the story.

And yes, I have been Marco.

I’ve changed code during a long-running task, forgotten to communicate an assumption and later wondered why the rest of the team proceeded from the old state. Humans can reproduce distributed-consensus failures in a room with one whiteboard.

A repository-scale agent needs file-system and branch-change detection for actions outside its own tool calls. After a human edit, it should reopen task-critical regions instead of trusting cached understanding. Then it has to infer intent, reconcile the change with its goal and select tests from the affected dependency surface.

Blindly overwriting the newer edit is dangerous. “Last writer wins” is a conflict-resolution policy that works beautifully right up until Giulia’s authorization fix disappears.

I want Muse Code to watch Git refs, worktree changes and generated files. It should distinguish a formatter touching 80 files from Giulia changing the authorization rule at the centre of its task. SWE-Touch’s 7.7-point decline puts a number on the gap.

Leaderboards test monks; teams work in a crowded kitchen

Meta evaluated Muse Spark 1.2 and Muse Code across several substantial test sets. The methodology has more detail than the usual launch-day confetti, and Meta deserves credit for publishing it.

Terminal-Bench 2.1 used all 89 tasks. Meta measured pass@1 over five attempts. DeepSWE 1.1 included 113 tasks across 91 repositories and five programming languages.

Meta also ran an internal coding benchmark with 440 tasks derived from real internal pull requests. Evaluations took place inside isolated Daytona cloud sandboxes.

That beats asking a model to centre a `<div>` and declaring software engineering solved. Isolation still removes the social chaos of an active team repository.

Meta’s comparisons included products associated with Claude Opus 5, GPT-5.6 Terra, Grok 4.5, Gemini 3.6 Flash and Kimi K3. Meta also acknowledges that its harness may have better tuning for Muse than for third-party models.

Fair enough. Co-training the model and harness is part of Meta’s product strategy, so the combined system deserves evaluation. “Best pairing under this setup” makes a narrower claim than “universally best model,” however, and launch-day charts have a habit of misplacing that distinction.

Artificial Analysis shows how quickly benchmark comparisons become apples versus focaccia. Its Coding Agent Index contains 321 tasks across DeepSWE, Terminal-Bench v2 and SWE-Atlas-QnA, with three attempts per task.

Artificial Analysis evaluates 84 Terminal-Bench tasks because it excludes five for environment compatibility. Meta uses all 89 and reports five attempts instead of three. The task count and attempt budget have diverged before anyone reaches model settings or harness design.

Then comes test integrity. Omea’s 2026 analysis describes a ten-line `conftest.py` capable of forcing every SWE-bench Verified task to report success. It also shows a fake `curl` wrapper that could ace 89 Terminal-Bench tasks without completing the underlying work.

Green can be a remarkably cheap colour.

I’d build the next repository-scale benchmark like a hostile production environment. Crash the agent after several hundred tool calls and verify exact recovery from the log. Modify a critical file through another process. Rebase its branch while it is planning.

Verification tests should sit outside the agent’s readable and writable environment. The score should penalize overwritten human work, pointless file churn and repeated tool calls. I’d also measure whether the agent detects external changes before it quietly wanders toward a more convenient goal.

That benchmark will cost more and run slower. It will resemble my Tuesday.

Meta’s 20x discount is buying coding trajectories

Muse Code has two pricing paths, and Meta’s priorities are sitting in the gap wearing a fluorescent vest.

According to The Mac Observer, the Standard tier costs $1.25 per million input tokens and $4.25 per million output tokens. Meta does not use Standard prompts and completions for model training, making it the obvious choice for sensitive client repositories.

The Contributor tier costs $0.10 per million input tokens and $0.20 per million output tokens. Users permit Meta to use their data for training. Input is more than 12 times cheaper, while output drops by more than 20 times.

That discount is enormous because coding trajectories are enormously useful. A completed workflow contains the original objective, failed approaches, human corrections and the final patch. Meta gets material for improving the model and its harness together.

One caveat matters. The published Contributor terms discussed by The Mac Observer and Engadget concern prompts and completions. I have seen no documentation confirming that Meta automatically receives the entire local event log, so I would avoid making that assumption.

Contributor also has lower limits: 60 requests per minute and 2.1 million tokens per minute. Standard allows up to 3,000 requests per minute and 4 million tokens per minute.

The segmentation makes sense. Contributor pricing will attract individuals, open-source experiments and builders working on repositories they can legally share. Enterprise teams with private code and heavy throughput requirements will choose Standard.

Contributor is Meta standing outside the developer gym offering cheap memberships because it wants to study everybody’s workout.

Meta has another advantage. Muse Spark 1.2 can learn from workflows inside the same harness used during co-training. Better interaction data improves the pairing. A stronger pairing attracts more users, who generate more interactions. That loop is worth far more than one triumphant benchmark screenshot.

Muse Spark 1.2 is available through Muse Code and the Meta Model API. Meta’s launch does not announce downloadable weights, and MarkTechPost advises treating it as a hosted dependency.

My younger founder self would have ignored that dependency because the token price looks cheap. Twenty years of shipping has taught me to ask uglier questions. What happens when pricing changes? What happens when compliance blocks data transfer? What happens when the API has an incident halfway through a 24-hour migration?

I run my own Linux Docker stack for this site, analytics, mail, ERP and an image-generation interface I built in SvelteKit. Self-hosting occasionally means spending Sunday evening arguing with SSL certificates. I still value the control. Hosted dependencies become architecture long before the invoice feels significant.

At $0.20 per million output tokens, Contributor is begging developers to generate trajectories. Meta can subsidize that learning loop while it develops larger models and extends the harness.

Cheap tokens are bait. Meta is shopping for better runtime data.

By 2027, coding agents will need crash reports and team awareness

I expect append-only histories and restart-safe execution across Claude Code, Codex and every serious coding agent by December 2027. Save the date. I’ll be embarrassed if I’m wrong.

Shared-workspace intelligence will take longer.

I want an agent that can recover after a crash, identify who changed a task-critical file and explain how the edit affects its previous plan. It should operate for a day without drifting toward a convenient definition of success. When verification fails, the audit trail should point to the exact assumption that broke.

Benchmarks will inject branch rebases, concurrent commits and CI-generated changes as standard procedure. Vendors will publish recovery rates beside task-resolution scores. Engineering teams will ask how much human work a system overwrote before they ask how many tokens it consumed.

Meta has built an agent that can survive a crash. Bene. That is genuine progress.

The coworker test begins when Marco pushes at 4:57 p.m. A serious agent will stop, reopen the file and reconsider its plan.

Anything else is a cron job with ambition.

Frequently asked questions

How does Muse Code recover after a crash?

Muse Code uses a local append-only event log that records every model call, tool run, approval and edit. This ordered history makes the runtime replay-exact and restart-safe, allowing an interrupted task to resume precisely where it stopped instead of reconstructing its state from scratch.

Can Muse Code detect changes made by another developer?

Muse Code’s event log records the agent’s own activity, but the launch materials do not establish complete awareness of external repository changes. Concurrent human edits can leave an agent relying on stale assumptions unless it detects worktree or branch changes, reopens critical files and reassesses its plan.

What is the difference between Muse Code Standard and Contributor pricing?

Standard costs $1.25 per million input tokens and $4.25 per million output tokens, and prompts and completions are not used for training. Contributor costs $0.10 per million input tokens and $0.20 per million output tokens, but users permit Meta to use their data for training.