两台 Mac Studio 跑 816B：Meta 的 Muse Spark Open 到底交付了什么

2026 年 10 月 15 日，Meta 发布了 Muse Spark Open 的权重——这是它 4 月首次亮相以来第一次把 Muse Spark 系列开源。8160 亿总参数，每个 token 激活约 420 亿；上下文最高 100 万 token；输入可以混用文本、图像、音频和视频，输出只有文本。起点是 8 月发布的 Muse Spark 1.2，之后加上了安全后训练，让模型在没有 Meta 自家服务护栏的情况下也站得住。Meta 把它称为「美国实验室迄今最强开放权重模型」。但真正有信息量的是几组对比：在 Meta 自家的 JobBench 上它得 61.8，是另一个美国开放模型 Inkling（31.1）的两倍；在 Terminal-Bench 2.1 上它的 76.4 低于 Kimi K3 的 85，也低于 GLM 5.3 与 Qwen3.8；而在 MCP-Atlas 工具调用上它以 89.2 超过了 Meta 列出的所有对手。选开放权重从来不是选「最强的模型」，而是选「你能控制的那一档能力」，这次发布把这道缝切得很清楚。

两台合计 1TB 内存的台式机是演示。生产环境是另一场对话。

这次发布的坐标：开放权重 + 自托管，但不是最强

把三件事分开看会更清楚。第一是能力层级：Meta 明确说最强系统仍然是闭源的，Muse Wonder 只能走 API 与 Muse Code；Muse Spark Open 是从 8 月的 Muse Spark 1.2 出发，补上安全后训练之后放出来的开放权重版本。第二是可及性：权重可以从 Hugging Face 下载，也在 AWS、Google、Microsoft 的模型目录里，首日有 7 家服务商提供托管访问，包括 Groq 和 Fireworks AI——换句话说，Meta 不指望所有人都自己跑。第三是许可：新的 Muse Model License。这三层叠在一起，构成一个很具体的定位：它不承诺「最好」，它承诺「你能自己拿在手上、而且不用付费改造」。

# The Muse Model License has thresholds in it. Encode them, do not remember them.
from dataclasses import dataclass

PROHIBITED = ("military", "weapons", "critical_infrastructure")

@dataclass
class UseCase:
    name: str
    is_hosted_service: bool = False
    trailing_12m_gross_revenue_usd: float = 0.0
    sector: str = "general"
    ships_inside_own_product: bool = True
    displays_attribution_label: bool = False

REVENUE_THRESHOLD = 20_000_000

def assess(uc):
    findings = []
    if uc.sector in PROHIBITED:
        findings.append(("BLOCK", f"sector '{uc.sector}' is excluded by the licence"))
    if uc.is_hosted_service and uc.trailing_12m_gross_revenue_usd > REVENUE_THRESHOLD:
        findings.append(("AGREEMENT_REQUIRED",
                         f"hosted service above ${REVENUE_THRESHOLD:,} trailing-12m revenue"))
    if uc.is_hosted_service and uc.trailing_12m_gross_revenue_usd <= REVENUE_THRESHOLD:
        findings.append(("OK", "hosted service under the revenue threshold, no separate agreement"))
    if not uc.is_hosted_service and uc.ships_inside_own_product:
        findings.append(("OK", "adapting or shipping in your own product carries no fee"))
    if not uc.displays_attribution_label:
        findings.append(("LABEL_REQUIRED", 'must show a "Built with Muse Spark Open" label'))
    return findings

for uc in [
    UseCase("internal coding agent", sector="general", displays_attribution_label=True),
    UseCase("resold inference API", is_hosted_service=True, trailing_12m_gross_revenue_usd=48_000_000),
    UseCase("small hosted wrapper", is_hosted_service=True, trailing_12m_gross_revenue_usd=1_200_000),
    UseCase("defence analytics", sector="military", displays_attribution_label=True),
]:
    print(uc.name)
    for status, note in assess(uc):
        print(f"   {status:18} {note}")

816B 总参数 / 42B 激活：一个模型，两种硬件问题

稀疏模型的参数必须分成两个数看，因为它们对应两种完全不同的瓶颈。总参数决定「装不装得下」：BF16 约 1520GiB、FP8 约 760GiB、NVFP4 约 380GiB，这是硬门槛，容不下就是容不下。激活参数决定「每 token 多贵」：约 420 亿的激活量让解码算力接近一个 42B 稠密模型，所以延迟体感不差。Meta 的演示恰好卡在两者的交点上——两台 M5 Ultra 的 Mac Studio，合计约 1TB 内存，用 MLX 连成一套，在这个池子里 FP8 大概占七成多，剩下给 KV 缓存。这个演示值得读的地方不是「Mac 也能跑 816B」，而是它证明了「激活参数小、总参数大」这个组合把自托管的门槛从「算力」挪到了「内存容量」——而内存是可以靠堆机器解决的。

# 816B total, 42B active. Two numbers, two different hardware problems.
PRECISIONS = {"bf16": 2.0, "fp8": 1.0, "nvfp4": 0.5}

def weights_gib(total_b, precision):
    return total_b * 1e9 * PRECISIONS[precision] / (1024 ** 3)

def active_flops_per_token(active_b):
    """Rough dense-equivalent decode compute: 2 x active params per token."""
    return 2 * active_b * 1e9

print("Muse Spark Open (816B total / 42B active)")
for p in ("bf16", "fp8", "nvfp4"):
    print(f"  {p:6} weights -> {weights_gib(816, p):7.0f} GiB")
print(f"  decode compute per token -> {active_flops_per_token(42)/1e9:.0f} GFLOPs (dense-equivalent)")

print()
print("The demo setup: two Mac Studio M5 Ultra, ~1TB memory combined, linked by MLX.")
for p in ("fp8", "nvfp4"):
    share = weights_gib(816, p) / 1024
    print(f"  {p:6} fills {share*100:5.1f}% of a 1TB pool, leaving {1024 - weights_gib(816, p):6.0f} GiB for KV cache")

# Active parameters set how fast each token decodes; total parameters set whether
# the thing fits at all. A 42B decode profile inside an 816B footprint is the
# whole trade: good latency, unforgiving capacity.

发布首日就有七家推理服务商提供托管访问，这说明了 Meta 预期谁来服务它。

许可证里的阈值，比摘要重要

Muse Model License 被 Meta 描述为「有限的商业条款」，但真正决定你能不能商用的是几个具体阈值。改造模型、或把它内置进你自己的软件发布，不收费。把模型作为托管服务来卖、且过去 12 个月总营收超过 2000 万美元，需要另签协议——注意这是「且」，两个条件同时满足才触发。产品上必须显示「Built with Muse Spark Open」标识。军事与关键基础设施用途被明确排除。这类条款的实际风险不在大公司，而在两种中间情况：一个营收刚好越过 2000 万美元门槛的托管 API 服务，以及一个忘了加标识的小产品。所以合规检查应该是代码而不是记忆——把阈值、标识要求和禁用类别写进 CI，而不是写进某个人的脑子里。

# Video input is the expensive modality. Budget it before you promise anything.
def frame_budget(duration_s, fps, tokens_per_frame, context=1_000_000, reserve=0.15):
    frames = duration_s * fps
    usable = context * (1 - reserve)          # leave room for prompt and output
    per_clip = frames * tokens_per_frame
    return {
        "frames": round(frames),
        "tokens": round(per_clip),
        "clips_in_one_context": int(usable // per_clip) if per_clip else None,
        "fits": per_clip <= usable,
    }

print("1M-token context, 15% held back for prompt and output:")
for dur, fps, tpf in ((10, 1, 900), (60, 1, 900), (60, 2, 900), (600, 1, 900)):
    print(f"  {dur:>4}s @ {fps} fps, {tpf} tok/frame ->", frame_budget(dur, fps, tpf))

# Meta's own demo was different in kind: it walked footage frame by frame to pick
# and crop shots, which is an offline batch job, not a single-context problem.
# Decide which of the two you are actually building.

全模态输入：视频是账单上最贵的那一栏

输入支持文本、图像、音频和视频，输出只有文本，这个不对称本身就说明了成本结构。文本和图像的成本是线性可预测的，视频不是：按每秒 1 帧、每帧约 900 token 估算，10 秒的视频约 9000 token，60 秒约 5.4 万 token，而每分钟 2 帧的 60 秒视频直接翻倍到约 10.8 万 token。100 万 token 的上下文看起来很大，但如果要留出 15% 给提示词和输出，那么长视频只能在「抽帧稀疏化」和「切成多段分别处理」之间做取舍。Meta 自己的演示也说明了这一点：逐帧扫描 DaVinci Resolve 素材、挑出并裁切适合竖屏的视频——这是离线批处理任务，不是「把整个视频塞进一个上下文」的任务。先想清楚你在建的是哪一种。

# 220 tools across 36 MCP servers. Routing is the hard part, not calling.
from dataclasses import dataclass

@dataclass
class Tool:
    server: str
    name: str
    description: str

TOOLS = [
    Tool("github-mcp", "create_pull_request", "Open a pull request from a branch"),
    Tool("github-mcp", "list_issues", "List issues filtered by label and state"),
    Tool("postgres-mcp", "run_query", "Execute a read-only SQL query"),
    Tool("postgres-mcp", "describe_table", "Return column names and types for a table"),
    Tool("slack-mcp", "post_message", "Send a message to a channel"),
    Tool("fs-mcp", "read_file", "Read a text file from the workspace"),
]
STOPWORDS = {"a", "an", "the", "to", "of", "in", "and", "for", "by", "with", "from"}

def index(tools):
    inv = {}
    for t in tools:
        for w in (t.name + " " + t.description).lower().replace("_", " ").split():
            if w not in STOPWORDS:
                inv.setdefault(w, []).append((t.server, t.name))
    return inv

INV = index(TOOLS)

def route(task, k=3):
    words = [w for w in task.lower().split() if w not in STOPWORDS]
    votes = {}
    for w in words:
        for key in INV.get(w, []):
            votes[key] = votes.get(key, 0) + 1
    ranked = sorted(votes.items(), key=lambda kv: -kv[1])[:k]
    return [(name, server, score) for (server, name), score in ranked]

for task in ("list open issues in the repo", "read the config file and describe the table", "post a message"):
    print(task, "->", route(task))

# MCP-Atlas gives the model the task without naming the tools, which is the same
# discipline as this: retrieve first, then call. Selection quality is what a
# 89.2 measures, not raw API competence.

模型许可证是一份带阈值的合同。要看阈值，不要只看摘要。

220 个工具、36 台 MCP 服务器：难的是挑，不是调

MCP-Atlas 上 89.2 分之所以值得单独拿出来说，是因为这个基准给出的任务是自然语言描述，不告诉你该用哪个工具——模型要自己在 36 台在线 MCP 服务器、220 个工具里判断调哪个、按什么顺序调。这和真实 Agent 的困境一模一样：工具多了之后，瓶颈从「会不会用工具」变成「能不能在几百个工具里检索对」。工程上的解法也很朴素：给工具建倒排索引（把工具名和描述分词建表），拿到任务后先检索排序，只把前几名塞进上下文，再让模型做最终选择。工具数量到几百时，这一步做得好不好，比换一个更强的模型对成功率的提升更明显。

# Long-horizon agents need a stopping rule, or a 42B decode profile runs all night.
import time
from dataclasses import dataclass, field

@dataclass
class Budget:
    max_steps: int = 40
    max_seconds: float = 900.0
    max_failed_steps: int = 4
    started: float = field(default_factory=time.time)
    steps: int = 0
    failures: int = 0

    def exhausted(self):
        if self.steps >= self.max_steps:
            return "step budget"
        if time.time() - self.started >= self.max_seconds:
            return "wall clock budget"
        if self.failures >= self.max_failed_steps:
            return "consecutive failure budget"
        return None

def run_loop(plan, observe, budget):
    history = []
    while True:
        reason = budget.exhausted()
        if reason:
            return {"stopped": reason, "steps": budget.steps, "history": history}
        action = plan(history)
        result = observe(action)
        budget.steps += 1
        budget.failures = budget.failures + 1 if not result.get("ok") else 0
        history.append({"action": action, "ok": result.get("ok"), "obs": result.get("obs")})
        if result.get("done"):
            return {"stopped": "goal reached", "steps": budget.steps, "history": history}

STEPS = [{"ok": False, "obs": "test failed"}, {"ok": False, "obs": "test failed"},
         {"ok": True, "obs": "test passed"}, {"ok": True, "done": True, "obs": "ship it"}]
state = {"i": 0}

def plan(history):
    return f"attempt_{state['i']}"

def observe(action):
    i = state["i"]
    state["i"] += 1
    return STEPS[i] if i < len(STEPS) else {"ok": True, "done": True}

print(run_loop(plan, observe, Budget()))

# Self-correction only works if there is a stop condition that is not "the model
# decided it was finished." Give the loop a budget it cannot argue with.

长任务需要一个模型没法讨价还价的停止条件

Muse Spark Open 主打长周期 Agent 任务：计划、执行、观察、自我纠错，训练数据里包含多文件重构和长时间调试会话。这类循环最大的工程风险不是能力不足，是停不下来——一个 42B 解码档位的模型在夜里跑一整晚，账单和副作用都是真实的。所以循环必须有外部预算：最大步数、最长墙钟时间、连续失败次数上限，三个里任一触发就强制退出，而不是等模型自己判断「完成了」。这条和 Arena 对齐指数那篇的发现互相印证：会话越长、步骤越多，越权和虚报完成的概率越高；把预算做成循环不可协商的一部分，比事后过滤日志便宜得多。另外一句提醒——Muse Code 订阅默认是 Contributor 模式，允许用你的提示词、代码和文件换更多用量；在把私有仓库粘进去之前先检查这个开关。

# Open weights, closed flagship. Compare what you would actually be choosing between.
ITEMS = [
    {"name": "Muse Spark Open", "open": True,  "params_b": 816, "context": 1_000_000,
     "note": "weights on Hugging Face; 7 hosted providers; Muse Model License"},
    {"name": "Muse Wonder",     "open": False, "params_b": None, "context": None,
     "note": "Meta Model API and Muse Code only; $4/M input, $20/M output"},
    {"name": "Muse Wonder Full","open": False, "params_b": None, "context": None,
     "note": "Power and Maximum Muse Code plans only, not on pay-as-you-go API"},
    {"name": "Muse Glimmer",    "open": True,  "params_b": 30, "context": None,
     "note": "previous open release, August 2026"},
]

def choose(need_self_host, need_max_capability, need_training_control):
    for item in ITEMS:
        if need_max_capability and not item["open"]:
            return item["name"]
    if not need_self_host:
        return "hosted API of your choice"
    for item in ITEMS:
        if item["open"] and (item["params_b"] or 0) >= 100:
            return item["name"]
    return "Muse Glimmer"

print("max capability, no self-hosting ->", choose(False, True, False))
print("self-host, frontier-ish          ->", choose(True, False, False))
print("self-host, small footprint       ->", choose(True, False, True))

# One more thing worth flagging: Muse Code subscriptions default to Contributor
# mode, which permits training on your prompts, code and files in exchange for
# more usage. Check that setting before you paste a private repository in.