🏢 Meta's Coding Agent Play
Theo opens with a confession: he's a fan of Meta's software contributions, not their social products. From React and React Native powering the modern web, to open-weight Llama models becoming a generic term for open-weight AI, Meta's track record of giving away genuinely useful technology is formidable. Their VR/AR contributions and internal developer tooling — they rewrote PHP into Hack and built custom version control on Mercurial because Git was too slow at their scale — position them uniquely for the coding agent space. 0:00
The core thesis: Meta has been quietly working on a line of models called Muse, historically inaccessible beyond a web playground. Now they're productizing it for code — not just the model, but the tools around it. Zuckerberg announced Muse Code in beta, a terminal coding agent powered by Muse Spark 1.2, their new coding-focused model. Theo's framing: "It's been a while since I've seen a lab publish benchmark numbers where they're not in first place in anything, but that doesn't mean it's a bad model." 0:55
📢 The Announcement
Zuckerberg's announcement post frames Muse Code as a terminal agent that "takes on complex software engineering tasks across large repos — lining changes, writing code, validating the results." Key architectural claims: 2:55
| Feature | Claim |
|---|---|
| Background agents | Specialized agents stay active the whole session, building context over time instead of starting from scratch on every task 5:25 |
| Sub-agent fan-out | Big jobs spawn parallel sub-agents in isolated work trees — your working copy is never touched. Tested with 6 simultaneous game features, no collisions 5:51 |
| Long-running tasks | 1,000+ tool calls over 24 hours on an Nvidia Hopper kernel optimization task; kept finding improvements well beyond initial exploration 6:10 |
| Auditability | Every model call, tool run, and edit has a local event log before execution. If it crashes mid-task, it picks up exactly where it left off — no lost work, no re-prompting 6:43 |
📊 Benchmarks & Positioning
Meta's published benchmarks are notable for what they don't include: no Fable, no Soul — only Opus 5 and GPT-5.6 ("Terra"). This is a deliberate choice of comparison targets, and Theo calls it out. 4:14
| Benchmark | Muse Spark 1.2 | Comparison |
|---|---|---|
| Terminal Bench 2.1 4:23 | Slightly beats Terra, slightly behind Opus 5 | Big jump from Spark 1.1 → 1.2; 1.1 was barely available publicly |
| Deep SWE 4:56 | Slightly higher than Grok 4.5 | Still behind Terra and Opus; far behind Soul and Fable |
| Meta Internal Coding Bench 5:13 | 2nd place | Suspiciously close grouping of Terra, Gemini 3.6 Flash |
| Intelligence Index 7:58 | 54 (up from 43 in April) | Tied with GPT-5.5 and Grok 4.5; +11 points in 3 months |
| Omniscience (hallucination) 28:20 | About as bad as 56 Soul, slightly better than Kimi K3 | Contradicted by live testing — Theo watched it hallucinate aggressively |
The trajectory is the real story: +11 points on the Intelligence Index in three months (43 → 54), with three releases in four months. At this pace, the gap to frontier models could close meaningfully. But as Theo tests live, benchmark numbers and real-world capability don't always align. 8:18
💰 The Pricing Story
This is where Muse Spark 1.2 becomes genuinely interesting. Meta offers two pricing tiers with a staggering gap between them: 7:14
| Tier | Input (per 1M tokens) | Output (per 1M tokens) | Cached Input |
|---|---|---|---|
| Standard | $1.25 | $4.25 | $0.15 |
| Contributor 7:34 | $0.10 | $0.20 | $0.002 |
During Theo's entire session — including two game rewrites, a full codebase audit, and sub-agent planning work — the total spend was ~40 cents. For comparison, similar work with Fable and Opus on his machine racked up $32. That's a 100× cost gap. Even switching to the standard tier (at ~10-20× the contributor price), the same session would cost $4–8 — still far cheaper than Anthropic's offerings. 29:45
⚡ Speed & Throughput
Speed is Muse Spark 1.2's second killer feature. Per OpenRouter telemetry (measuring real user throughput, not lab benchmarks): 12:06
| Metric | Muse Spark 1.2 | 56 Soul | Grok 4.5 |
|---|---|---|---|
| Average TPS | 191 12:18 | ~30 | 50–52 |
| P50 TPS | 162 | 40s–50s | — |
| Peak TPS | 316 12:40 | 134 | — |
During the live demo, Muse Spark 1.2 delivered a full codebase architecture overview in under 30 seconds. For reference, Theo observed 174 TPS during actual coding tasks — roughly 5× faster than 56 Soul and 3× faster than Grok 4.5. The model's speed makes it feel qualitatively different: fast enough that you don't context-switch while waiting, which changes the interaction model from "submit and wait" to "submit and watch." 14:14
🔍 Live Demo: Codebase Audit
Theo's first test: point Muse Code at the T3 codebase (fully open-source) and ask for an architectural overview. Result: delivered in under 30 seconds. A follow-up prompt asking it to find suspicious patterns in the event sourcing model — cross-platform behavior quirks, unnecessary bandwidth usage, latency issues — produced a detailed HTML report with findings, all generated from the model's own investigation. 13:32
AGENTS.md), Muse's harness reads Claude Code's config — confirmation that Meta is targeting Claude Code users for migration.
The HTML skill was detected and used automatically — Muse found it, parsed it, and applied the formatting conventions without being explicitly told to. Theo noted that the CLI itself is "a lot more stable and less annoying than Claude Code," though "Pi still smokes it overall." 36:31
⚔️ Head-to-Head: Muse vs Fable vs DeepSeek
To get a real comparison, Theo ran the same event-sourcing audit prompt across three models and had them review each other's work. The results reveal the gap between speed and depth: 15:38
| Model | Time to Complete | Quality Assessment |
|---|---|---|
| Muse Spark 1.2 | <1 minute 16:01 | Generated HTML report; UI paths included; fast but surface-level |
| Fable 5 | 4+ minutes 16:08 | More accurate root cause analysis; self-assessed as superior |
| DeepSeek V4 Flash | ~5 minutes 16:30 | Found Muse's plan "meaningfully better" — models disagree on each other |
The cross-review was revealing: Fable thought its own plan was better (more accurate root causes, better coverage), while DeepSeek thought Muse's plan was superior. This model-on-model disagreement is a reminder that comparative assessments from LLMs are opinion, not measurement. Theo's takeaway: "It's a solid model for the price, but I don't know if I would trust it for really heavy end-to-end work yet." 17:47
🎮 Fish Game Remakes — Speed Over Correctness
One of Theo's standard tests: take his "crappy fish game" and have the model remake it in 2D and 3D. The speed was staggering: 18:00
| Task | Muse Spark 1.2 | Opus 5 (reference) |
|---|---|---|
| 2D Fishlop remake | 2 min 39 sec 18:45 | Multiple hours |
| 3D Fishlop remake | <5 min 18:06 | Over an hour |
But the results tell a nuanced story. The 3D version had fish swimming backwards, broken mouse-look (only left/right, no up/down), and no collision detection. The 2D version had solid sprite animations, shadows, and contrast — "it has a weird type of taste that I haven't seen models have." When told to fix the bugs, it partially succeeded (fish direction corrected) but introduced new issues (space bar fed fish AND moved up). 20:45
🧩 Sub-Agent Architecture & Rate Limits
Muse Code's sub-agent system closely mirrors Claude Code's: Theo asked it to investigate how to integrate Muse as a provider into T3 Code, and it immediately spawned multiple sub-agents working in parallel. The voice-to-text input was surprisingly good — "the first good terminal voice-to-text I've seen in any of these CLIs." 24:13
But the experience was marred by aggressive rate limiting. Even on the paid standard tier, sub-agent fan-outs hit rate limits constantly: "Why would you make a sub-agent flow like this if your APIs can't even handle it, Meta?" The model doesn't enforce parallel limits like other harnesses — it happily spawns 7+ sub-agents simultaneously, then they all hit the wall together. 24:46
The sub-agent plan quality was middling. When asked to create an integration plan for Muse in T3 Code, it hallucinated an entire investigation path around "anti-gravity" — completely off-target. When corrected ("I'm in Muse right now"), it recovered and produced a plan that Fable reviewed as 4.8/10 vs Fable's own 7/10. Soul's review was harsher: "a slaughterhouse," scoring it 4/10 on repository/API fidelity. 32:24
📋 PR Audit: The Killer Use Case
Despite the disappointments, Theo found Muse Spark 1.2's killer use case: bulk PR auditing. Two tests proved it: 37:51
| Test | Scope | Time | Cost (Contributor) | Result |
|---|---|---|---|---|
| Open PRs audit 38:18 | All open PRs on T3 Code | 4 min | ~$0.10 | Confidence scores, clean/dirty merge labels, clickable links — "one of the better PR review pages I've gotten" |
| Extended audit 40:00 | All PRs updated in past 5 days | <5 min | ~$0.10 | 222 PRs indexed, organized by mergeability |
The PR audit page had features that more expensive models often miss: clickable PR links, confidence scores per PR, clean vs. dirty merge classification, and status assessments. Theo genuinely preferred its layout to versions generated by other models. At the standard tier, the same audit would cost ~$2 — still excellent value. 38:46
🎨 Design Taste & Vibe
Throughout testing, Theo kept returning to an observation: Muse Spark 1.2 has a different flavor from other models. Its design output — tested on witchai.dev across multiple prompts — showed: scroll-linked graphics, tilted reminder cards, squircle elements, and a layout sensibility reminiscent of "early Gemini 3 Pro era." It's not better, but it's different in ways that feel intentional rather than derivative. 21:12
Theo's description: "It's like a little bit of seasoning that they added that other stuff doesn't have. This really is a model for enthusiasts right now." He compared it to playing with an interesting toy programming language — different in ways that aren't necessarily production-ready, but genuinely fun to explore. The model has a "vibe" that suggests Meta trained it on something distinct, not just another distillation of popular model outputs. 41:24
🏁 Verdict: Who Should Use Muse Code
✅ Good for:
- 🔹 Bulk PR auditing and triage — 200+ PRs in 5 minutes for 10 cents is unbeatable value
- 🔹 Codebase overview and architecture exploration — fast, cheap first-pass analysis
- 🔹 Rapid prototyping — game remakes, UI sketches, throwaway experiments where speed matters more than correctness
- 🔹 Signal-from-noise extraction — categorizing PRs, generating summaries, log analysis, title generation
- 🔹 Enthusiasts who like trying new things — the model has a genuinely different flavor worth experiencing
- 🔹 Meta employees — if you work at Meta, this is probably your second or third model after Opus/Fable
❌ Not ready for:
- 🔸 End-to-end feature development — hallucinations and incomplete implementations are too frequent
- 🔸 Complex multi-step integrations — the Muse→T3 Code integration attempt produced a broken UI with non-functional provider
- 🔸 Production merges without review — "I would rather wait 2-3× longer and have something I can almost certainly merge"
- 🔸 Heavy sub-agent workflows — rate limits on both tiers cripple the parallel agent architecture
- 🔸 Anyone unwilling to share data with Meta — the standard tier is still cheap, but 10-20× more expensive than contributor
✅ Key Takeaways
- Muse Code is a Claude Code clone — literally. It reads Claude Code's config directory, mirrors its sub-agent UX, and targets the same user base. Meta is an Anthropic house internally, and it shows in the tool design.
- Contributor tier is a 10–20× price gap. $0.10/M input, $0.20/M output vs $1.25/$4.25 standard. Meta subsidizes usage because they need training data. At contributor pricing, it's the cheapest model at this capability level.
- 191 TPS average — 5× faster than 56 Soul. Speed changes the interaction model from "submit and wait" to "submit and watch." Peak throughput hits 316 TPS on OpenRouter.
- 100× cheaper than Fable/Opus for equivalent work. Theo's full session: 40 cents vs $32 for comparable Anthropic usage. Even the standard tier is still far cheaper.
- Killer use case: bulk PR auditing. 222 PRs indexed and organized in 5 minutes for $0.10, with clickable links and confidence scores. This is genuinely production-useful, not just a demo.
- Good at acting like a smart model, less good at being one. Muse understands sub-agent decomposition, artifact generation, and tool workflows — but its actual code quality and end-to-end reliability lag significantly behind frontier models.
- Rate limits cripple the sub-agent architecture. Both contributor and paid tiers throttle aggressively, making the headline "parallel sub-agents" feature frustrating to use in practice.
- Hallucination is real and aggressive. The model invented an entire investigation around "anti-gravity" when asked to research Muse's own SDK. Omniscience scores look decent on paper; real-world behavior disagrees.
- Trajectory matters: +11 points in 3 months. Three releases in four months, 43 → 54 on the Intelligence Index. At this pace, Meta could close the gap to frontier models within a few more releases.
- The CLI is surprisingly polished for a v0.1. Stable, less annoying than Claude Code, supports worktrees and YOLO mode. But it's closed-source — an odd choice for Meta, an "open-source company at heart."
- Different flavor, not better. Muse Spark 1.2 has a distinct design sensibility — scroll-linked graphics, squircle elements, a "Gemini 3 Pro era" aesthetic — that makes it feel like a genuinely different model, not a distillation of others.
- Not a daily driver — yet. "No one should use this model as their day-to-day coding model." But as a cheap, fast signal-extraction tool for PR reviews, codebase exploration, and rapid prototyping, it's already useful.
🔗 Resources & Links
- 📺 Original video — full 44-minute exploration by Theo - t3.gg
- 🐦 Zuckerberg's announcement thread — Muse Code beta launch on X/Twitter
- 📊 Artificial Analysis — independent model benchmarks and pricing comparisons
- 🔀 OpenRouter — real-world throughput and speed telemetry for Muse Spark 1.2
- 🎨 witchai.dev — design comparison site used for model taste testing
- 💻 T3 OSS on GitHub — the open-source codebase used for live testing
- 🦎 Greptile T-Rex — sponsor: code review bot with sandboxed verification