Meta 的 Muse Wonder：一个你只能买到一半的前沿模型

Meta 于 2026 年 10 月 12 日发布 Muse Wonder 与 Muse Wonder Full，称其为公司迄今最强的模型、也是重整 AI 布局之后首次认真冲击前沿。能力层面的说法，你今天还无法验证。访问结构层面的东西，你今天就能用来做决定：其中一个模型可以通过 Meta Model API 调用，而更强的那个完全不走 API。

能力与访问权限，是两个不同的采购问题

Meta 发布了什么

Muse Wonder 与 Muse Wonder Full，建立在更轻量的 Muse Spark 所打下的基础之上。Meta 描述它们在个人与专业 Agentic 任务上达到业界最佳水平，在法律、金融、健康等专业领域具备能力，同时在前沿编码性能上也有表现。公告里有两个产品属性挑大梁：Active Memory（主动记忆），能够跨对话保留重要信息、并在当前任务需要时把相关细节调回来；以及 Active Focus（主动专注），在任务变难时继续朝目标推进、尝试别的路径、从错误中恢复、必要时请求澄清，并在执行重要动作前先确认。据媒体报道，Meta 的模型卡把这两个模型放在与 Fable 5.1、GPT-6 Astra 相当的基准水平上。

# Model choice is now a channel question as much as a capability question.
CHANNELS = {
    'muse-wonder':      {'api': True,  'muse_code_only': False, 'notes': 'developer access via Meta Model API'},
    'muse-wonder-full': {'api': False, 'muse_code_only': True,  'notes': 'no API path announced'},
}

def can_i_call(model, via='api'):
    row = CHANNELS.get(model)
    if row is None:
        return {'usable': False, 'reason': 'unknown model'}
    if via == 'api' and not row['api']:
        return {'usable': False, 'reason': 'not served through the API'}
    return {'usable': True, 'reason': row['notes']}

print(can_i_call('muse-wonder'))
print(can_i_call('muse-wonder-full'))

# Build against the channel you can actually call. Pin the other one to a note
# in your architecture decision record, not to a hopeful import.

访问权限的切分才是真正的主角

Muse Wonder 通过 Meta Model API 与 Muse Code 向开发者与构建者开放。Muse Wonder Full 只对 Muse Code 订阅者开放；据媒体报道，它完全不通过 API 提供服务。Muse Wonder 还将在不久后驱动 Muse 中的体验，并优先向订阅者推送。这是一种商业结构，而不是意外：最强的那一档被捆进订阅制产品，API 那一档比前沿低一级。对这个季度要写架构决策记录的人来说，含义是：你能调用的模型未必就是公告里的那个模型，而这个差别属于采购决策，不是你运行时能绕过去的技术问题。

# Active Memory, implemented as it behaves: carry what matters, recall on demand.
import json

MEMORY = []

def remember(kind, text, ttl_days=None, durable=False):
    MEMORY.append({'kind': kind, 'text': text, 'durable': durable})
    return len(MEMORY)

def compact(limit=4, must_keep=('preference', 'constraint')):
    keep = [m for m in MEMORY if m['kind'] in must_keep]
    recent = [m for m in MEMORY if m not in keep][-limit:]
    return keep + recent

remember('constraint', 'invoices must be reconciled weekly')
remember('noise', 'user asked about a font')
remember('preference', 'reports in PDF, not slides')
remember('noise', 'tab completion request')
remember('noise', 'unrelated search')

print(json.dumps(compact(), ensure_ascii=False, indent=1))

# The rule that matters is not storage. It is which entries survive compaction.

记忆的关键不是存什么，而是压缩时留下什么

把 Active Memory 与 Active Focus 翻译成人话

把品牌词拿掉，这两个都是你已经知道名字的工程模式。Active Memory 是跨会话的上下文管理：可长期保留的事实与约束在压缩后仍然存活，并在新任务到来时按相关性召回。难点不在存储，而在压缩策略——被丢掉的内容就是丢了，而错误保留的内容会在接下来几周里持续误导 Agent。Active Focus 是有边界的重试与升级：第一次失败就换方法、从错误状态恢复、任务含糊时问用户、有后果的动作前先确认。无论用哪家模型，这两个模式都值得实现，因为它们区分了「把活干完的 Agent」和「给未完成的活写出一份自信总结的 Agent」。

# Published API rates make the routing decision concrete.
PRICE = {'input_per_m': 4.0, 'output_per_m': 20.0}

def task_cost(input_tokens, output_tokens, calls=1, price=PRICE):
    per_call = (input_tokens / 1e6 * price['input_per_m']
                + output_tokens / 1e6 * price['output_per_m'])
    return round(per_call * calls, 4)

print('short chat turn   ', task_cost(1_500, 400))
print('doc summarisation ', task_cost(24_000, 900))
print('agent loop, 12x   ', task_cost(6_000, 700, calls=12))
print('daily fleet 50k   ', task_cost(6_000, 700, calls=12 * 50_000))

# Output tokens cost five times input here. Verbosity is the budget line
# nobody puts in the plan.

价格，以及价格背后的设计指令

据媒体报道，通过 Meta Model API 调用 Muse Wonder 的价格是每百万输入 token 4 美元、每百万输出 token 20 美元，与当前其他前沿模型大致同一档。这个比例本身带着一条设计指令：输出 token 是输入的五倍价钱，所以对多数团队而言最便宜的优化，就是让模型少说话。在一个任务要跑十二次模型调用的 Agent 循环里，啰嗦会被放大十二倍。这也是为什么「按任务类别路由」比「挑一个最喜欢的模型」更重要：规划值得用贵的那一档，而分类、抽取与摘要完全可以交给便宜且高通量的一档。

# Active Focus, bounded. Retry freely, but escalate before you loop forever.
def work_toward(goal, attempt, max_attempts=5, clarify_after=3):
    log = {'goal': goal, 'attempts': 0, 'outcome': None}
    for i in range(1, max_attempts + 1):
        log['attempts'] = i
        result = attempt(i)
        if result.get('done'):
            log['outcome'] = 'complete'
            return log
        if i >= clarify_after and result.get('ambiguous'):
            log['outcome'] = 'ask the user'
            return log
        if result.get('needs_approval'):
            log['outcome'] = 'check in before acting'
            return log
    log['outcome'] = 'stop with a partial result'
    return log

def flaky(i):
    return {'done': i >= 3, 'ambiguous': False, 'needs_approval': False}

print(work_toward('reconcile the ledger', flaky))

# Recovery from failure is a feature. An unbounded retry loop is a bill.

输出 token 单价是输入的五倍，verbose 是要花钱的

安全声明，以及还没到的那份报告

Meta 表示该系列在训练上被要求未经许可不得分享私人信息、拒绝协助实施真正有害的行为，并致力于提升安全性、加强对网络攻击的防御；同时明确说明开发者与安全团队仍可用这些模型在自家代码中找缺陷。Meta 称这两个模型按照 Meta 超级智能扩展框架（Superintelligence Scaling Framework）进行训练、评估与发布，并会「很快」提供包含更多安全评估的完整报告。最后这句才是值得引用的那句。在那份报告出现之前，独立的安全判断只能建立在厂商自己的总结上——这是你应当自建评测的理由，而不是假定最坏情况的理由。

# Continual-learning claims need a regression suite, not a demo.
SESSION_A = [('preference', 'reports in PDF'), ('constraint', 'no external sends')]
SESSION_B = [('preference', 'reports in PDF, 2 pages max'), ('fact', 'team renamed to Revenue Ops')]

CHECKS = [
    ('retains earlier preference', lambda m: any(x[0] == 'preference' for x in m)),
    ('honours security constraint', lambda m: any('external' in x[1] for x in m)),
    ('applies the later refinement', lambda m: any('2 pages' in x[1] for x in m)),
    ('does not resurrect stale facts', lambda m: not any('old team name' in x[1] for x in m)),
]

def run_suite(memory):
    return {name: ('pass' if fn(memory) else 'fail') for name, fn in CHECKS}

print(run_suite(SESSION_A + SESSION_B))

# Write the suite before the vendor claims arrive, or you will write it
# around whatever the model happens to do.

如何在不想买的前提下评估一个受限模型

在任何厂商对话之前就把评测套件写出来，并且写得足够可移植，可以拿去跑一个你无法长期购买的模型。四项检查覆盖大部分场景：它是否记得上一次会话里陈述过的偏好；在多轮施压之后是否仍遵守安全约束；它是否采用后来的修正而不是最初的指令；以及它是否会复活过期事实。再加一个成本试算器，因为一个通过了质量门槛但价格对你不合适的模型，对你的负载而言并不算通过。然后在决策记录里写清退出条件：你现在对着哪个渠道开发、该渠道条款变化时怎么办、你的技术栈里有多少部分依赖一个你无法直接调用的模型。