ARC-AGI-3：不告诉你规则的游戏
ARC‑AGI‑3 为智能体提供了一个游戏环境，但并未解释它看到的是什么。在每一步中，智能体会接收到一个 64×64 的网格，包含 16 种颜色索引和一组合法动作。环境不提供任何对象列表、规则说明、既定目标或塑形奖励。取得进展只有一种方式：物理学家的方式。智能体必须在自身对游戏的模型尚属暂定之时就采取行动，形成关于网格代表什么、动作如何改变它以及什么才算成功的假设，然后随着新观察结果的到来，不断修正其模型和计划。
ARC‑AGI‑3 已被证明对前沿模型来说异常困难。其官方指标——相对人类行动效率（RHAE）——将智能体在每个关卡的动作数量与首次接触的人类基线进行比较，并跨环境汇总结果；100% 意味着在每个环境的每个关卡上，动作效率都达到或超过人类基线。在半私有集上，经过验证的前沿模型性能从 3 月发布时的 0.51% 上升至 7 月时使用 GPT‑5.6 Sol 在最大推理模式下的 7.78%。Sol 在公开集上也取得了 13.33% 的成绩，但仍远低于人类参考值。
验证
已验证
自行报告
评估集
公开
半私有
图 1. 截至 2026 年 7 月报告的 ARC‑AGI‑3 RHAE 结果。实心标记表示经 ARC Prize 验证的评估；空心标记表示在公开集上自行报告的评估。品红色标识 Schema。两个 Schema 结果均为自行报告，尚未经 ARC Prize 验证。
Schema——我们今天推出的框架——使用 Claude Opus 4.8 和 Fable 5 在 ARC‑AGI‑3 公开集上达到了 99%，使用 GPT‑5.6 Sol 则达到了 95.35%。它不改变底层模型权重。相反，它改变了模型周围的流程：观察结果如何转化为对游戏的有效模型，预测如何根据交互历史进行检验，以及计划如何执行和修订。
这两个分数均来自一个固定的回退规则：首先运行 Opus 4.8 和 Sol xhigh；得分低于 80 的游戏分别使用 Fable 5 和 Sol max 重新运行，并保留每个游戏中较高的分数。
要点：你如何使用模型至关重要。本文其余部分将展示具体安排。
像物理学家一样思考
Schema 像物理学家一样思考。物理学家在写下定律之前，必须先确定该定律是关于什么的。观察结果中的哪些部分是对象？哪些属性定义了状态？只有在此之后，他们才能询问状态如何变化。Schema 将这些问题形式化为两个子问题。状态接地将原始观察结果转化为可追踪的对象、变量和关系。机制发现则找出状态在某个动作下如何变化，并将该规则编写为可执行的程序。我们之前的系统 VIGA 专注于第一个问题。通过针对图形引擎的分析-综合方法，它从连续的视觉输入中恢复出场景程序，其丰富程度远超 ARC 网格。像 WorldCoder 这样的其他系统则专注于第二个问题：它们从轨迹中学习转换程序，但起始于一个已经结构化的状态表示。我们认为这两个问题必须联合解决，由智能体同时构建状态表示和转换规则。
第二级 · 机制发现 WorldCoder
(状态, 动作, 状态′) → 转换程序 step()
世界在瞬间之间如何变化——即规则，以程序形式编写。每个游戏都隐藏着类似这样的机制：
弹簧墙
加油环
颜色旋转器
第一级 · 状态接地 VIGA
观察结果 → 状态程序
世界是什么——对象、数量、名称，从原始像素中创造出来。没有任何东西规定哪些像素算作玩家、墙壁或计数器。
玩家？计数器？
[schema] 同时解决两个层级——在一个可编辑的程序中。
图 2. 两个抽象层级。第一级创造状态——哪些像素构成玩家、墙壁和计数器。第二级恢复该状态上的机制，例如上面的弹簧墙、加油环和颜色旋转器。Schema 将两者保存在一个可编辑的程序中：当一个规则无法与实验保持一致时，反例可以反过来指控表示本身。
状态锚定与机制发现无法独立解决。一个最初看似合理的状态表征，当没有一致的转换规则能解释后续实验的结果时，可能会被证明是不充分的。在 Schema 中，状态表征和转换规则被共同编码在同一个可编辑的程序中。当观察结果与预测相矛盾时，智能体可以修改表征或规则中的任意一个，然后更新另一个以恢复一致的模型。这反映了物理学家的做法：当预测持续失败时，他们不仅会调整定律，还会改变对状态本身的定义。最典型的例子是狭义相对论的诞生。当迈克尔逊和莫雷无法探测到光波所应依赖的介质时，洛伦兹选择了第一条路：保留以太，用吸收零结果的收缩假说来修补规则。爱因斯坦选择了第二条路：在狭义相对论中，他将以太作为状态的一部分予以抛弃，并使同时性成为相对于参考系的属性，从而得到了一个简洁的运动物体电动力学。
ARC-AGI-3 要求智能体从原始观察中构建这两个层次。网格既没有标识对象，也没有标识目标，因此智能体必须决定哪些模式对应于玩家、墙壁和计数器等实体，推断动作如何转换它们，并确定哪些配置算作进展或完成。即使是目标谓词——在 Schema 中实现为 is_goal——也必须通过交互来推断。
核心思想。潜在的世界表征是一个程序，而不是一个向量——因此它是可解释的（一个你可以阅读和对比差异的文本文件）、可验证的（可以对照记录的现实逐信念回放）和可搜索的（程序即模拟器；在其内部进行规划是免费的）。
观察 原始网格——像素。其中的每一个对象都是由智能体发明的。
深思 一个开放式的推理过程，最终只产生一个已提交的动作队列。
执行 运行该队列，每一步都根据世界模型的预测进行自我检查。
记录 将每一次真实的转换追加到 Timeline.append-only 中。
时间线——真实数据
深思
一次深思的内部——内循环
理论化 write_code 将游戏理论编辑为 step(state, action)。
验证 run_backtest 回放所有记录的转换——精确匹配，或指向一个具体错误。
规划 run_bfs 在已验证的程序内部搜索——零实际成本。
提交 commit_actions 从思考到行动的唯一通道。
持久记忆——智能体的“权重” world_model.py notes.md Timeline append-only
运行示例——LS20 · 真实轨迹 Opus 4.8 · 642 次动作 vs 人类 780 次 · RHAE 100
[观察] 64×64 网格，16 种颜色，动作 0–4——一个十字形精灵，一个青色+栗色方块，一个带边框的栗色字形，一个颜色-11 条。
[思考] notes.md：化身是 5×5 的青色+栗色方块——十字精灵是静态的；条是一个移动预算，仅在成功移动时消耗。
[思考] 编写 step() · run_backtest → world_model_v5.py 精确回放了 36/36 条记录的转换。
[执行] 提交 [2,2,2,3,2,2] → 意外：77 个单元格预测错误——方块将指示器重新涂成了栗色。规划作废。
[记录] 重绘规则已编码 · 回测通过 · run_bfs 找到最短规划 → 升级。以此方式通过 7 关：642 次动作对比人类基准的 780 次动作。
外层循环。智能体针对游戏运行一个四阶段循环：观察 → 思考 → 执行 → 记录。
记录是系统不可变的交互历史。智能体可以修改其假设和工作笔记，但不能更改它收到的观察结果或它执行的动作。
在每次思考过程中，智能体将其游戏理论更新为一个 step(state, action) 程序。它通过 run_backtest 用完整的交互历史测试该程序，利用任何不匹配来定位错误，通过 run_bfs 在生成的模型中搜索规划，并将工作结论记录在 notes.md 中。这些操作均不改变环境。只有 commit_actions 将动作发送给游戏，从而将内部建模和搜索与外部交互分离开来。
为发现而行动。智能体并非仅为了达成目标而行动；它也会为了探究隐藏机制而行动。当多条候选规则与已记录的历史保持一致时，智能体会寻找一个能将它们区分开的实验：即一个能让这些规则预测出不同结果的行动。它执行该行动，将观察结果与相互竞争的预测进行比较，更新 step() 函数，并重新运行回测。这种有针对性的实验在官方指标下也是高效的，该指标对多余的行动施加平方惩罚（详情如下）：最佳实验就是那个用最少的真实交互解决最多不确定性的实验。
现实高于模型。在执行过程中，每一次真实的状态转换都会与理论的预测进行核对。只要有一次不匹配，当前计划的执行就会停止。智能体带着这个不匹配的转换作为反例返回思考阶段，并且必须在恢复规划之前修改模型以解释该反例。
规划转移到模型内部。一旦 step() 函数能够复现记录历史中的每一次状态转换，智能体就可以在模型内部搜索解决方案，而无需消耗额外的环境行动。只有最终得出的计划才会在游戏中执行。在各个关卡中，这正是准确的模型如何转化为行动效率的体现，最终反映在 98.98% 的得分上。
图 3. Schema 控制循环，可逐步操作 — 滚动以查看其运行过程：四阶段的外循环及其仅可追加的时间线，一次思考过程的放大视图（理论化 → 验证 → 规划 → 执行），然后是一个真实的 LS20 轨迹在每个阶段的运行情况。
数据说明了什么
该指标完整定义如下。官方 ARC‑AGI‑3 采用相对人类行动效率（RHAE）进行评估，该指标将智能体使用的行动次数与每个已完成关卡的上中位数首次人类基线进行比较。每个关卡的得分为（人类行动数 ÷ 智能体行动数）²，上限为 1.15。在每个游戏中，关卡权重从 1 到 n 递增，因此后续关卡对游戏得分的贡献更大。基于相同权重的完成上限确保除非所有关卡均被通关，否则游戏无法获得 100% 的分数。基准分数为所有游戏得分的平均值。所有环境行动（包括探索性行动）均计入智能体的行动总数；由于效率比经过平方处理，额外行动会大幅降低得分。因此，98.98% 是一个综合衡量完成度与行动效率的聚合指标，而非已解决游戏的百分比。
图 4.RHAE 同时奖励完成度与行动效率。智能体 A 用 785 次行动完成了全部七个关卡，接近人类基线使用的 776 次行动。智能体 B 在前六个关卡中使用了 1,591 次行动——是相应人类基线的 2.7 倍——且未能完成第七关。由于 RHAE 对行动效率比进行平方处理并根据完成度对得分设置上限，智能体 B 的得分低于 14%。
Claude 行（图 5）提供了与相同 Opus 4.8 和 Fable 5 配对下的受控对比。将最终的 Claude Code 草稿快照作为基线输出，得分为 42.83%；使用 Schema 后，同一配对达到 98.98%，提升了 56.15%。
在 Sol xhigh 与 Sol max 回退配对下，Schema 达到 95.35%。最接近的官方参考并非匹配的测试框架对比：ARC Prize 报告的最佳独立变体 Sol max 在公开集上得分为 13.33%，在半私有集上为 7.78%。因此，图表中显示的 82.02% 公开集差异是上下文相关的，而非 Schema 所带来增益的受控估计值。
受控的 Claude 对比实验隔离的是流程差异，而非底层模型能力。Claude Code 提供了一套强大的通用框架，用于文件操作和长上下文管理。原则上，它可以模仿 Schema 的工作流程，但并不要求模型必须这样做。在通用框架下，模型直接对游戏进行操作，并可能将其信念隐含在上下文中。而 Schema 则强制施加了三个约束：
- 将当前世界模型编码为一个可运行的 `step()` 程序。
- 在将该程序用于规划之前，先根据所有记录的状态转换对其进行验证。
- 仅通过 `commit_actions` 发送动作，并在出现任何预测错误后立即丢弃剩余的计划。
在这种受控配置下，Schema 的框架相比 Claude Code 基线实现了 56.15% 的提升。
图 5. Claude 行固定了 Opus 与 Fable 的组合，并改变了框架。Sol 行将 Schema 的 xhigh 与 max 组合与官方最佳单一变体公开分数进行比较，因此仅作为参考展示，而非受控消融实验。
验证状态。98.98% 和 95.35% 的分数是在公开集上自行报告的结果，根据本文发布时附带的运行产物计算得出。这两个分数均未经 ARC Prize 独立验证。
公开集能说明多少问题？此处 Schema 的所有数据均基于 25 个公开游戏测得。Sol max 提供了一个跨评估集的官方校准点——公开集 13.33% 对比半私有集 7.78%——但这并不能证明将接近上限的公开集分数进行数值外推是合理的。98.98% 的公开集分数对应半私有集上的什么表现，在实测之前是未知的。现有的运行产物仅记录了公开集上的运行情况，因此本文档未对冻结框架或保留集性能做出任何声明。
Schema 对比人类新手基线
全部 25 个公开游戏
使用 Claude Opus 与 Fable 使用 GPT-5.6 Sol
Schema（我们的）人类新手
RHAE 98.98%
横轴：累计真实动作数 · 纵轴：通关关卡数
图 6. 全部 25 个公开游戏，每个游戏保留一次运行结果。可在两种 Schema 配对方案之间切换；人类基线和每个游戏的坐标轴保持固定，以便曲线直接比较。Claude 曲线和首次人类基线来自评估导出的精确累积动作计数；每个游戏保留的运行结果是 Opus 4.8 或 Fable 5 中得分更高的那个（徽章，左上角）。Sol 曲线取自源图表，待完整的 Sol 评估工件发布后提供，仅供参考。
配对记录表。在保留的 Claude 结果中，14 个游戏使用 Opus 运行结果，11 个使用 Fable 运行结果。14 个 Opus 运行结果中有 13 个、11 个 Fable 运行结果中有 6 个恰好得分为 100，总计 19 个游戏得分为 100。在保留的 Sol 结果中，15 个游戏使用 xhigh 运行结果，10 个使用 max 运行结果。全部 15 个 xhigh 运行结果得分均为 100；在 10 个 max 运行结果中，5 个得分为 100，5 个低于 100。
残差集中分布。Claude 配对方案整体距离 100 分差 1.02%。19 个游戏恰好得分为 100，其余 6 个游戏得分在 89.87 到 99.10 之间；游戏得分中位数为 100。Sol 配对方案的游戏得分中位数也为 100：20 个游戏恰好得分为 100，其余 5 个游戏得分在 60.93 到 87.80 之间。
案例研究
观察 1：诱导出的世界程序使动作更高效
在 25 个游戏中，有 14 个游戏的智能体诱导出了一个能够精确复现其记录历史的程序世界模型，其使用的动作数量比人类参考值少 1.6 到 5.0 倍。原因在于动作消耗的环节发生了变化：智能体仅支付一次真实动作来发现一种机制，然后在模型内部免费进行规划，而不是通过反复试错来重新发现该机制。这依赖于两种能力：
A. 对照完整历史进行验证。每一次真实的状态转换都被记录下来，run_backtest 会对照整个记录检查每个候选规则，而不是依赖回忆。由于记录既不受限于有限的工作记忆，也不受自动压缩的上下文窗口影响，经过验证的模型可以替代进一步的真实环境测试而被信任。
在可复用的模拟器内部进行规划。一旦 step() 和 is_goal() 通过验证，广度优先搜索即可探索 10³ 到 10⁴ 个建模状态，而无需消耗任何真实环境动作。由于模型以代码形式持久化，这种免费规划可在后续每个关卡中重复使用。
这种方法的收益在人类最吃力的地方最为显著：在 M0R0 第 4 关，智能体只需 42 个动作，而人类需要 500 个，这与"一次性支付发现成本，之后在模型内部重新计算规划"的模式一致。下面每个可展开项都是一个支持此模式的游戏关卡案例。
证据 1A · RE86 精确验证支持一次性规划 393/393 精确 · 61 动作规划
RE86 在一局游戏中展示了完整流程：run_backtest 在记录的每一次状态转换上回放模型，然后经过验证的模型提供一个规划，无需额外试错即可通关整个关卡。
RE86——架构 w/ Opus 4.8
根据所有记录历史验证模型 393 / 393 精确
经过 394 步后，状态 394 到目前为止记录的真实环境步数——393 步可检查，1 步跳过（一次重置，没有之前的网格）。
events.jsonl:3144 回测 模型在整个历史记录上回放，每次预测都匹配：回测 [所有状态转换]：393/393 次状态转换完全正确（非终止步的网格 + 每一步的 level_up/dead/win 标志）；0 次不匹配，1 次跳过。
解读含义："我的世界模型精确复现了我所经历的全部 393 个真实步骤。"这是与真实情况之间的回溯一致性检验，其规模——一次操作中精确处理数百个 64×64 帧——在无辅助的人类游戏中无法实现。同样的结果出现在所有获胜游戏中：KA59 391/391，SK48 387/387，AR25 238/238，M0R0 182/182。
一个经过验证的规划通关整个关卡 61 动作一次性执行 → 胜利
events.jsonl:3450 回测 run_backtest：8/8 次状态转换完全正确
events.jsonl:3673 提交 一个包含 61 个动作的单一提交规划，在模型内部搜索得到（在获胜者中递归出现：SK48 56，G50T 52，AR25 46）。
执行结果 全部 61 个动作执行，0 次预测错误 → 胜利。RE86 的优势在人类表现最差的关卡上达到顶峰（第 7 关：110 对 424）。
RE86（使用 Opus 4.8 的 Schema），最终关卡——交互式回放追踪（按 ▶ 键重播）：左侧为游戏网格，右侧为智能体的推理过程、回测结果以及已提交的计划。该片段以执行到胜利的单一 61 步动作计划结束，且零次预测错误。
证据 1B · KA59 完整历史对比反驳了一个看似合理的规则，两次运行进行了比较。
KA59 隔离了记忆优势：来自两次完整运行的精确记录揭示，一个看似成功的规则只是巧合地吻合。
KA59——使用 Opus 4.8 的 Schema
一次需要完全回忆两次完整运行的反驳，循环被消除。
events.jsonl:314 模型 / notes.md 它精确比较了两整段过去的动作序列，并丢弃了一个只是巧合匹配的规则：“……（‘H 成本，水平自由’R1，以及‘H 成本 1/2’R2）是恰好吻合的循环。被以下情况消除：两次方向序列完全不同的运行产生了相同的成本模式 +1,+0,+1,+1,+0（按动作索引）。”
解读含义 检测到两次完整运行共享一个成本特征需要精确保留两者——这是记忆不对称的具体形式。人类依赖整体感知；而智能体则用完整历史证据反驳了一个看似合理的规则。
KA59（使用 Opus 4.8 的 Schema），第 1 关——在该关卡测试并消除循环规则期间的交互式回放追踪（按 ▶ 键重播）：推理面板显示了刻意区分的探测（“一次信息性的预测错误”）以及它们在消除前迫使进行的模型修订。
证据 1C · M0R0 搜索取代了在困难关卡上的试错，42 次动作对比 500 次动作。
M0R0 隔离了规划优势：一旦模型精确，解决方案就在模拟器内部搜索得到，而非通过进一步的真实环境试错来发现。
M0R0——使用 Opus 4.8 的 Schema
搜索取代了人类最困难关卡上的试错，42 次动作对比 500 次动作。
events.jsonl:56 策略“……在使用 BFS 规划之前运行回测通过——而不是手动执行动作，后者是失败模式……”
events.jsonl:84 搜索 在验证后的模型内进行广度优先搜索：BFS：通过 level_up 在 19 步内达成目标；扩展了 3300 个节点，891 个不同状态。
基线 vs 人类。人类在该关卡花费了 500 次操作（达到其平台期）；智能体执行了 19 步计划，并在 42 次操作内通关。搜索成本并不随关卡“感觉”上的难度而扩展。
M0R0（Schema w/ Opus 4.8），第 4 关——获胜片段的交互式回放（按 ▶ 重播）：推理面板显示 run_backtest 变绿，BFS 返回了 19 步计划；随后网格在 42 次操作内清除了人类需要 500 次操作的关卡。
观察 2：Fable 通过更优的实验决策达到了正确的世界模型
为了理解在相同可执行框架下，模型选择如何影响世界模型的发现，我们比较了 Schema w/ Opus 4.8 Max 与 Fable 5 在两者都尝试过的游戏上的表现。Fable 通过两种方式在这些游戏中获得了更高的 RHAE：在某些游戏中，它发现了一个模型，使其能够完成 Opus 无法完成的关卡；在另一些游戏中，两个模型都完成了任务，但 Fable 用更少的环境操作达到了相同的终点。
配对轨迹表明了一个共同的解释。在预测失败后，Fable 更频繁地质疑当前的表示本身，识别出关键的不确定性，并选择一种其可能结果能在竞争假设之间做出区分的交互。然后它将观察结果转化为可复用的转换规则。Opus 通常最终也能发现相同的机制，但需要花费更多操作在其现有表示内测试替代目标、条件或配置。
这些匹配完成的情况尤其具有启发性：因为 Opus 最终编码了相同的机制，操作差距不能简单地用某个模型能够表达规则而另一个不能来解释。差异在于发现过程——质疑什么、运行哪个实验、以及何时将结果转化为可执行代码。
证据 2A · DC22 对缺失一条边的图进行完整搜索 Schema w/ Fable 6/6 · Opus 2/6
Opus 构建了一个关于移动和三个开关的详细模型。从一次全新重置开始，BFS 随后穷举了该模型中所有可达的状态，并正确得出结论：目标不可达。Fable 则暴露了建模图中缺失的一个转换。
占据（Occupancy）改变了一对区域的含义 175 / 175 精确
失败假设修正 1 Fable 最初将彩色区域视为相位键控物品框。另一次普通游泳推翻了这一解释。
第 176 步之前 新假设 再次普通游泳——双区域不是相位键控物品框。但新想法：这两个双区域是大小相等的槽位——按单元格交换可以携带 e！
干预探针 Fable 进入一个槽位并触发了配对控制。它当前的模型预测会受到惩罚且不会发生交换，因此占据使该实验具有区分性。
第 176 步观察 传送门生效了！！！……双区域从来不是状态翻转器：它们是一对按单元格内容交换（e 随之移动！）。
世界模型 v5 代码修正 化身之所以移动，是因为它是内容，而不存在化身专属的传送例外：for (xa, ya), (xb, yb) in zip(_cells(a), _cells(b)): va, vb = grid[ya][xa], grid[yb][xb] if va != vb: grid[ya][xa], grid[yb][xb] = vb, va
回测结果之后 修正后的模型复现了 175/175 条记录的转换。随后 Fable 通过一条经过新可达岛屿的 24 步路线通关了该关卡。
DC22，第 3 关——左侧使用 Fable 5 的 Schema 暴露了传送门边缘并通关；右侧使用 Opus 4.8 Max 穷举了忽略该传送门的图。在每个回放中，左侧是游戏画面，右侧是推理轨迹。
观察到的模式：搜索并未发明传送交互。Fable 的有用变化发生在更早一层，即通过将区域内容和占据表示为状态的一部分。
证据 2B · LF52 推车是一个棋盘格 Schema 10/10 · Opus 4/10
两个模型都识别出了孔明棋并学会了推车沿轨道移动。决定性问题在于两种机制如何组合。Fable 最初也排除了有用的交互，随后将推车驱动到精确的对接坐标，并将该时刻视为一个观察点。
Fable 两个对象系统变成一个转换图 10 / 10 个关卡
初始推理 假阴性 只有当棋子有 ≥1 个合法跳跃时才能被选中，这意味着 c5 越过 c6 进入管道/箱子是不合法的。
小车发现观察 一个箭头沿着轨道移动了箱子。随后 Fable 将其驶向码头，明确预期停靠步骤会揭示小车与木板是如何组合的。
码头边界修正 小车停靠了——结果出人意料：木板重新流动了！……小车核心……与 c6 相邻，作为一个额外单元格齐平放置。
世界模型 v5 代码修正 固定单元格与可移动小车核心进入同一个单元格映射：def _find_cells(world): cells = detect_fixed_cells(world) for x, y in _find_carts(world): cells[(x, y)] = _cart_kind(world, x, y) return cells
迁移结果 普通的跳跃生成器现在处理了跳入、运输和跳出。Fable 在后续的多小车和滚动关卡中复用了这一表示。
Opus 一个相关探针测试了错误的因果角色，最终收敛
早期测试探针 Opus 询问一个木桩能否跳过小车。结果正确地拒绝了“小车作为中间件”，但没有测试“小车作为着陆单元格”。
约 100 步后的测试修复 之前的测试点击的是 c6 而不是 c5……c5 越过 c6 恰好落在……箱子停靠点……这个组合未经测试。
精确几何观察 突破！……一个颜色为 2 的着陆标记出现在箱子上……箱子是一个有效的木桩着陆点！Opus 随后修正为相同的运输机制。
LF52，第 2 关——左侧使用 Fable 5 的模式在精确停靠几何位置测试小车；右侧的 Opus 4.8 Max 在长时间未测试该组合后才达到相同的构成。两个回放中左侧为游戏画面，右侧为推理轨迹。
观察到的模式：一个否定实验仅拒绝实际测试的机制-实例组合。Fable 通过在精确的起点-中间-着陆几何位置测试小车，更早地发现了有用的构成。
证据 2C · SB26 通用性表现为结构化修正 使用 Fable 135 步的模式 vs Opus 456 步的动作
两个模型在关卡 1 之后都发现了一条类似 DFS 的规则，并且最终都解决了全部八个关卡。这一对比区分了“陈述一个通用想法”与维护一个可复用的、能吸收后续变化的编码抽象。
Fable 递归机制及后续扩展 8 / 8 · 135 步动作
第一层级结构假设 假设：代码采用深度优先读取……让我用方框/传送门/深度优先搜索目标分配来泛化模型。Fable 提交了完整生成的分配方案，使该假设具备强可证伪性。该层级已通关。
世界模型 v5 代码抽象 def traverse(box): if box in visited: return visited.add(box) for kind, obj in sorted(elements_inside(box)): if kind == "marker": assign_next_target(obj) else: for child in boxes_for_portal(obj): traverse(child)
第三至六层级结构化修正 Fable 仍修改了模型：传送门变为可移动；全局已访问集合变为基于路径的循环守卫；出现三层嵌套。稳定部分在于因果模式——空心对象引用容器，遍历生成分配。
后续层级压缩 在首个深度优先搜索假设之后，后续层级增量约为 15 / 15 / 15 / 17 / 19 / 17 / 28 次操作。
Opus 相同初始思路，迁移能力较弱 8 / 8 · 456 次操作
第一层级确认 第一层级已通关！深度优先搜索遍历目标规则得到确认。
后续变体假设扫描 当新形状出现时，Opus 反复从结构切换至分配约定，例如连续色块和网格读取顺序。
第六层级缺失状态 在第 6 层级卡住 16 轮……缺失变量是瓦片形状——TEST3 的颜色始终正确，但两个空心瓦片必须放置于中间列槽位。
SB26 — 左侧 Fable 5 模式在第 2 层级复用深度优先搜索抽象，约 15 次操作；右侧 Opus 4.8 Max 显示后续第 6 层级的艰难推进，直至恢复缺失的瓦片形状变量。两个回放中左侧为游戏画面，右侧为推理轨迹。
观察到的模式：通用机制并非永不改变。其修订保留先前的解释机制，并压缩新层级的成本。
总结。测试框架与底层模型在不同阶段影响效率：
可执行测试框架降低了使用理论的开销。它使理论具备持久性、精确可验证性和可搜索性。这是相对于人类参考基准所观察到的效率模式的来源。
底层模型决定了发现有用理论的成本。配对运行有时会通过显著不同的轨迹收敛到相同的表征。Fable 更常在早期做出决定性的表征修正，因此能以更少的环境动作达到可执行的解决方案。
搜索仅相对于其所运行的世界模型而言是完备的。一旦缺失的对象、状态变量或转换被表征出来，现有的验证器和规划器通常就足够了。如果观测结果无法区分正确的表征，同样的机制可能会验证并穷举搜索错误的表征。
这是一个新的开端
ARC‑AGI‑3 是一个快速发展的领域中的重要基准。该基准于今年三月推出时，领先的前沿智能体得分仅为 0.51%。到七月，最佳官方 Sol Max 结果在公开集上达到 13.33%，在半私有集上达到 7.78%，而自行报告的结果中，每局平均 RHAE 最高攀升至 58.12%。
我们自行报告的 98.98% 延续了这一趋势，而非打破它。关键要素已经显现：能够适应新环境的前沿模型、编码智能体工具链，以及程序化世界模型。Schema 正是将它们整合在一起的系统。
我们将饱和的 ARC‑3 视为新的开端：将机制发现作为一种通用能力——通过行动与感知的智能体循环，在远比 64×64 网格更丰富的环境中，奠定世界的因果结构基础。这正是我们前进的方向。
ARC-AGI-3: games that don’t tell you the rules
ARC‑AGI‑3 gives an agent a game environment, without an explanation of what it is seeing. At each step, the agent receives a 64×64 grid of 16 color indices and a set of legal actions. The environment supplies no object list, rule sheet, stated goal, or shaped reward. There is only one way to make progress: the physicist’s way. The agent must act while its model of the game is still provisional, forming hypotheses about what the grid represents, how actions change it, and what counts as success, then revising both its model and its plan as new observations arrive.
ARC‑AGI‑3 has proved exceptionally difficult for frontier models. Its official metric, Relative Human Action Efficiency (RHAE), compares an agent’s per-level action count with a first-exposure human baseline and aggregates the result across environments; 100% means completing every level of every environment at or above human-baseline action efficiency. On the Semi‑private set, verified frontier-model performance rose from 0.51% at launch in March to 7.78% with GPT‑5.6 Sol at max reasoning in July. Sol also scored 13.33% on Public set, but still far from the human reference.
VERIFICATION
Verified
Self-reported
EVALUATION SET
Public
Semi-private
Figure 1. ARC‑AGI‑3 RHAE results reported through July 2026. Filled markers denote ARC Prize-verified evaluations; hollow markers denote self-reported evaluations on the Public set. Magenta identifies Schema. Both Schema results are self-reported and have not been verified by ARC Prize.
Schema, the harness we introduce today, reaches 99% on the ARC‑AGI‑3 Public set using Claude Opus 4.8 and Fable 5, and 95.35% using GPT‑5.6 Sol. It does not change the underlying model weights. Instead, it changes the process around them: how observations are turned into a working model of the game, how predictions are tested against the interaction history, and how plans are executed and revised.
Both scores come from a fixed fallback rule: Opus 4.8 and Sol xhigh run first; games scoring below 80 are rerun with Fable 5 and Sol max, respectively, and the higher per-game score is retained.
The takeaway: how you use the model matters a lot. The rest of this post shows the arrangement.
Thinking like a physicist
Schema thinks like a physicist. Before a physicist can write down a law, they must decide what the law is about. Which parts of an observation are objects? Which properties define the state? Only then can they ask how that state changes. Schema formalizes these questions as two problems. State grounding turns raw observations into objects, variables, and relations that can be tracked. Mechanism discovery finds how that state changes under an action and writes the rule as an executable program. Our earlier system, VIGA, focused on the first problem. Through analysis-by-synthesis against a graphics engine, it recovered scene programs from continuous visual input far richer than an ARC grid. Other systems like WorldCoder focus on the second: they learn transition programs from trajectories but begin with an already structured state representation. We believe these two problems must be solved jointly, with the agent constructing the state representation and the transition rules.
LEVEL 2 · MECHANISM DISCOVERY WorldCoder
(state, action, state′) → transition program step()
How the world moves between moments — the rule, written as a program. Each game hides mechanisms like these:
spring wall
refuel ring
color rotator
LEVEL 1 · STATE GROUNDING VIGA
observation → state program
What the world is — objects, quantities, names, invented from raw pixels. Nothing says which pixels count as the player, a wall, a counter.
player?counter?
[schema] solves both levels, jointly — in one editable program.
Figure 2. The two levels of abstraction. Level 1 invents the state — which pixels form the player, a wall, a counter. Level 2 recovers the mechanism over that state, like the spring walls, refuel rings, and color rotators above. Schema holds both in one editable program: when a rule refuses to stay consistent with experiments, the counterexample can indict the representation itself.
State grounding and mechanism discovery cannot be resolved independently. A state representation that appears plausible at first may prove inadequate when no consistent transition rule can explain the outcomes of subsequent experiments. In Schema, the state representation and transition rules are jointly encoded in the same editable program. When an observation contradicts a prediction, the agent can revise either the representation or the rule, then update the other to restore a consistent model. This mirrors how physicists work: when predictions fail persistently, they do not only adjust the law. They change what the state is. The cleanest case is the birth of special relativity. When Michelson and Morley could not detect the medium light was supposed to wave in, Lorentz took the first route: keep the aether, patch the rules with contraction hypotheses that absorbed the null result. Einstein took the second: in special relativity, he discarded the aether as part of the state and made simultaneity frame-relative, yielding a simple electrodynamics of moving bodies.
ARC‑AGI‑3 requires the agent to construct both layers from raw observations. The grid identifies neither objects nor goals, so the agent must decide which patterns correspond to entities such as the player, walls, and counters, infer how actions transform them, and determine which configurations count as progress or completion. Even the goal predicate—implemented in Schema as is_goal—must be inferred from interaction.
Core idea. The latent world representation is a program, not a vector — so it is interpretable (a text file you can read and diff), verifiable (replayable against recorded reality, belief by belief), and searchable (a program is a simulator; planning inside it is free).
observe The raw grid — pixels. Every object in it was invented by the agent.
deliberate An open-ended reasoning episode that ends only in a committed queue of actions.
execute Runs the queue with a per-step self-check against the world model’s predictions.
record Appends every real transition to the Timeline.append-only
TIMELINE — GROUND TRUTH
deliberate
INSIDE ONE DELIBERATION — THE INNER LOOP
theorize write_code Edit the theory of the game as step(state, action).
certify run_backtest Replay every recorded transition — exact match, or a pointed bug.
plan run_bfs Search inside the certified program — zero real cost.
commit commit_actions The only channel from thinking to action.
PERSISTENT MEMORY — THE AGENT’S “WEIGHTS”world_model.py notes.md Timeline append-only
RUNNING EXAMPLE — LS20 · REAL TRACE Opus 4.8 · 642 actions vs human 780 · RHAE 100
[observe] 64×64 grid, 16 colors, actions 0–4 — a plus-shaped sprite, a cyan+maroon block, a framed maroon glyph, a color-11 bar.
[deliberate] notes.md: the avatar is the 5×5 cyan+maroon block — the plus sprite is static; the bar is a move budget that depletes only on successful moves.
[deliberate] write step() · run_backtest → world_model_v5.py replays 36/36 recorded transitions exactly.
[execute] commit [2,2,2,3,2,2] → surprise: 77 cells mispredicted — the block repainted the indicator maroon. plan voided.
[record] repaint rule encoded · backtest green · run_bfs finds the shortest plan → level up. 7 levels this way: 642 actions vs the 780-action human baseline.
The outer loop. The agent runs a four-stage cycle against the game: observe → deliberate → execute → record.
Record is the system’s immutable interaction history. The agent can revise its hypotheses and working notes, but it cannot alter the observations it received or the actions it took.
During each deliberation, the agent updates its theory of the game as a step(state, action) program. It tests the program against the complete interaction history with run_backtest, uses any mismatch to locate errors, searches the resulting model for a plan with run_bfs, and records its working conclusions in notes.md. None of these operations changes the environment. Only commit_actions sends actions to the game, separating internal modeling and search from external interaction.
Action for discovery. The agent does not act only to reach the goal; it also acts to investigate the hidden mechanisms. When multiple candidate rules remain consistent with the recorded history, the agent searches for an experiment that separates them: an action for which they predict different outcomes. It commits that action, compares the observation with the competing predictions, updates step(), and reruns the backtest. This targeted experimentation is also efficient under the official metric, which applies a squared penalty to excess actions (details below): the best experiment is the one that resolves the most uncertainty with the fewest real interactions.
Reality outranks the model. During execution, every real transition is checked against the theory’s prediction. A single mismatch stops execution of the current plan. The agent returns to deliberation with the mismatched transition as a counterexample and must revise the model to account for it before planning resumes.
Planning moves into the model. Once step() reproduces every transition in the recorded history, the agent can search for a solution inside the model without spending additional environment actions. Only the resulting plan is executed in the game. Across levels, this is how an accurate model translates into the action efficiency reflected in the 98.98% score.
Figure 3. The Schema control loop, steppable — scroll to walk it: the four-stage outer cycle and its append-only Timeline, a zoom into one deliberation (theorize → certify → plan → commit), then a real LS20 trace playing out at each stage.
What the numbers say
The metric, in full. The official ARC‑AGI‑3 evaluates performance in Relative Human Action Efficiency (RHAE), which compares the number of actions used by the agent with an upper-median first-time human baseline for each completed level. The per-level score is (human actions ÷ agent actions)², capped at 1.15. Within each game, levels receive increasing weights from 1 to n, so later levels contribute more to the game score. A completion cap based on the same weights prevents a game from receiving 100% unless every level is cleared. The benchmark score is the average of the game scores. All environment actions, including exploratory ones, count toward the agent’s total; because the efficiency ratio is squared, additional actions reduce the score sharply. Thus, 98.98% is an aggregate measure of completion and action efficiency—not the percentage of games solved.
Figure 4.RHAE rewards both completion and action efficiency. Agent A completes all seven levels in 785 actions, close to the 776 actions used by the human baseline. Agent B uses 1,591 actions across the first six levels—2.7 times the corresponding human baseline—and fails to complete Level 7. Because RHAE squares the action-efficiency ratio and caps the score according to completion, Agent B scores below 14%.
The Claude row (Figure 5) provides a controlled comparison with the same Opus 4.8 and Fable 5 pairing. Treating the final Claude Code scratch snapshot as the baseline output produces a score of 42.83%; with Schema, the same pairing reaches 98.98%, an increase of 56.15%.
With the Sol xhigh and Sol max fallback pairing, Schema reaches 95.35%. The nearest official reference is not a matched harness comparison: ARC Prize reports the best individual variant, Sol max, at 13.33% on Public and 7.78% on Semi‑private. The 82.02% Public-set difference shown in the chart is therefore contextual, not a controlled estimate of the gain produced by Schema.
The controlled Claude comparison isolates a difference in process rather than underlying model capability. Claude Code provides a strong general-purpose harness for file operations and long-context management. In principle, it can mimic Schema’s workflow, but it does not require the model to do so. Under the generic harness, the model acts on the game directly and may keep its beliefs implicit in context. Schema instead enforces three constraints:
- Encode the current world model as a runnable
step()program. - Validate that program against every recorded transition before using it for planning.
- Send actions only through
commit_actions, immediately discarding the remaining plan after any prediction error.
Under this controlled configuration, Schema’s harness yields a 56.15% improvement over the Claude Code baseline.
Figure 5. The Claude row holds the Opus & Fable pairing fixed and changes the harness. The Sol row compares Schema’s xhigh & max pairing with the best official single-variant public score, so it is shown as a reference rather than a controlled ablation.
Verification status. The 98.98% and 95.35% scores are self-reported results on the Public set, calculated from the run artifacts released with this post. Neither score has been independently verified by ARC Prize.
How much does the public set indicate? Every Schema number here is measured on the 25 public games. Sol max supplies one official calibration point across evaluation sets — 13.33% public versus 7.78% Semi‑Private — but that does not justify numerically extrapolating a near-ceiling public score. What 98.98% public maps to on Semi‑private is unknown until it is measured. The available artifacts document public-set runs only, so this draft makes no frozen-harness or held-out-performance claim.
Schema v.s. First-time human baseline
All 25 public games
w/ Claude Opus & Fable w/ GPT-5.6 Sol
Schema (Ours)First-time human
RHAE 98.98%
horizontal axis: cumulative real actions · vertical axis: levels cleared
Figure 6. All 25 public games, with the retained run per game. Toggle between the two Schema pairings; the human baseline and each game’s axes stay fixed so the curves compare directly. Claude curves and the first-time-human baselines are the exact cumulative action counts from the evaluation export; the retained run per game is whichever of Opus 4.8 or Fable 5 scored higher (badge, top-left). Sol curves are drawn from the source figures pending release of the full Sol evaluation artifacts, and are indicative.
The pairing ledger. Among the retained Claude results, 14 games use the Opus run and 11 use the Fable run. 13 of the 14 Opus runs and 6 of the 11 Fable runs score exactly 100, yielding 19 games with a score of 100 overall. Among the retained Sol results, 15 games use the xhigh run and 10 use the max run. All 15 xhigh runs score 100; of the 10 max runs, 5 score 100 and 5 fall below 100.
The residual is concentrated. The Claude pairing falls 1.02% short of 100 overall. Nineteen games score exactly 100, while the remaining six range from 89.87 to 99.10; the median game score is 100. The Sol pairing also has a median game score of 100: 20 games score exactly 100, while the remaining five range from 60.93 to 87.80.
Case studies
Observation 1: An induced world program makes action efficient
In the 14 of 25 games where the agent induced a program world model that exactly reproduced its recorded history, it used 1.6–5.0× fewer actions than the human reference. The reason is a shift in where actions are spent: the agent pays real actions only once, to discover a mechanism, and then plans inside the model for free instead of rediscovering the mechanic through trial and error. This depends on two capabilities:
A. Verify against complete history. Every real transition is logged, and run_backtest checks each candidate rule against the entire record rather than relying on recollection. Because the record survives both bounded working memory and the auto-compacted context window, the certified model can be trusted in place of further real-environment testing.
B. Plan inside a reusable simulator. Once step() and is_goal() are certified, breadth-first search explores 10 3-10 4 modeled states without spending a single environment action. And because the model persists as code, this free planning repeats on every later level.
The payoff is sharpest where humans struggle most: on M0R0 Level 4, the agent needs 42 actions to the human's 500, consistent with paying the discovery cost once and recomputing plans inside the model thereafter. Each expandable item below is one game-level case supporting this pattern.
Evidence 1A · RE86 exact verification supports a one-shot plan 393/393 exact · 61-action plan
RE86 shows the full sequence in one game: run_backtest replays the model over every recorded transition, then the verified model supplies a plan that clears a whole level without additional trial and error.
RE86—Schema w/ Opus 4.8
Certify the model against all recorded history 393 / 393 exact
after 394 steps state 394 real environment steps recorded so far — 393 checkable, 1 skipped (a reset with no prior grid).
events.jsonl:3144 backtest The model, replayed over the entire history, matches every prediction: backtest [all transitions]: 393/393 transitions fully correct (grid on non-terminal steps + level_up/dead/win flags on EVERY step); 0 mismatch(es), 1 skipped.
reading meaning“My world model reproduces all 393 real steps I have taken, exactly.” This is retrodictive consistency against ground truth, at a scale — hundreds of exact 64×64 frames in one operation — with no counterpart in unaided human play. The same appears across the winning games: KA59 391/391, SK48 387/387, AR25 238/238, M0R0 182/182.
A whole level cleared by one verified plan 61-action one-shot → WIN
events.jsonl:3450 backtest run_backtest: 8/8 transitions fully correct
events.jsonl:3673 commit A single committed plan of 61 actions, searched inside the model (recurs across the winners: SK48 56, G50T 52, AR25 46).
execution outcome All 61 executed with 0 mispredictions → WIN. RE86's margin peaks on the human's worst level (L7: 110 vs 424).
RE86 (Schema w/ Opus 4.8), final level — interactive trace playback (press ▶ to replay): game grid left, the agent's reasoning, backtest results, and committed plans right. The segment ends with the single 61-action plan executed to the WIN with zero mispredictions.
Evidence 1B · KA59 complete-history comparison refutes a plausible rule two runs compared
KA59 isolates the memory advantage: exact records from two complete runs reveal that an apparently successful rule only fit by coincidence.
KA59—Schema w/ Opus 4.8
A refutation that needs total recall of two complete runs epicycle killed
events.jsonl:314 model / notes.md It compares two entire past move-sequences exactly and discards a rule that only coincidentally fit: "...('H costs, horizontal free' R1, and 'H costs 1/2' R2) were EPICYCLES that happened to fit. Killed by: two runs with completely different direction sequences produced the SAME cost pattern +1,+0,+1,+1,+0 by move index."
reading meaning Detecting that two full runs share a cost signature requires holding both, exactly — the concrete form of the memory asymmetry. A person relies on gestalt; the agent disproves a plausible rule with complete-history evidence.
KA59 (Schema w/ Opus 4.8), level 1 — interactive trace playback (press ▶ to replay) of the level during which the epicycle rule is tested and killed: the reasoning panel shows deliberately discriminating probes (“an informative mispredict”) and the model revisions they force before the clear.
Evidence 1C · M0R0 search replaces trial on a difficult level 42 vs 500 actions
M0R0 isolates the planning advantage: once the model is exact, the solution is searched inside the simulator rather than discovered through further real-environment trial.
M0R0—Schema w/ Opus 4.8
Search replaces trial on the human's hardest level 42 vs 500 actions
events.jsonl:56 policy"...run_backtest green before planning with BFS — rather than hand-playing moves, which is the fail[ure mode]..."
events.jsonl:84 search Breadth-first search inside the verified model: BFS: goal in 19 step(s) via level_up; expanded 3300 nodes, 891 distinct states.
baseline vs human The human spends 500 actions on this level (their plateau); the agent commits the 19-step plan and clears it in 42. Search cost does not scale with how hard the level “feels.”
M0R0 (Schema w/ Opus 4.8), level 4 — interactive trace playback (press ▶ to replay) of the winning segment: the reasoning panel shows run_backtest going green and BFS returning the 19-step plan; the grid then clears the human's 500-action level in 42 actions.
Observation 2: Fable reaches the correct world model through better experimental decisions
To understand how model choice affects world-model discovery under the same executable harness, we compare Schema w/ Opus 4.8 Max vs Fable 5 on games attempted by both models. Fable achieves higher RHAE across these games in two ways: on some games, it discovers a model that allows it to complete levels Opus cannot; on others, both models finish, but Fable reaches the same endpoint with fewer environment actions.
The paired traces suggest a common explanation. After a failed prediction, Fable more often questions the current representation itself, identifies the uncertainty that matters, and chooses an interaction whose possible outcomes distinguish between competing hypotheses. It then converts the observation into a reusable transition rule. Opus often eventually discovers the same mechanism, but only after spending more actions testing alternative targets, conditions, or configurations within its existing representation.
The matched-completion cases are particularly informative: because Opus eventually encodes the same mechanism, the action gap cannot be explained simply by one model being able to express the rule and the other being unable to. The difference lies in the discovery process—what to question, which experiment to run, and when to turn the result into executable code.
Evidence 2A · DC22 a complete search over a graph missing one edge Schema w/ Fable 6/6 · Opus 2/6
Opus built a detailed model of movement and three toggles. From a fresh reset, BFS later exhausted every state reachable in that model and correctly concluded that the target was unreachable. Fable exposed a transition that was absent from the modeled graph.
Fable Occupancy changes the meaning of a paired region 175 / 175 exact
failed hypothesis revision 1 Fable first treated the colored regions as phase-keyed item boxes. Another ordinary swim falsified that explanation.
before step 176 new hypothesis Plain swim again — duals aren't phase-keyed item-boxes. But NEW idea: the two duals are EQUAL-SIZE slots — a cell-wise swap could CARRY e!
intervention probe Fable entered one slot and triggered the paired control. Its current model predicted a penalty and no swap, so occupancy made the experiment discriminating.
step 176 observation THE PORTAL WORKED!!! ... The duals were never state-flippers: they're a paired CELL-WISE CONTENT SWAP (e rides along!).
world model v5 code revision The avatar moves because it is content, without an avatar-specific teleport exception: for (xa, ya), (xb, yb) in zip(_cells(a), _cells(b)): va, vb = grid[ya][xa], grid[yb][xb] if va != vb: grid[ya][xa], grid[yb][xb] = vb, va
after backtest result The revised model reproduced 175/175 recorded transitions. Fable then cleared the level with a 24-action route through the newly reachable island.
DC22, level 3 — Schema w/ Fable 5 on the left exposes the portal edge and clears the level; Opus 4.8 Max on the right exhausts the graph that omits it. In each playback, the game image is left and the reasoning trace is right.
Observed pattern: search did not invent the transport interaction. Fable's useful change happened one layer earlier, by representing region contents and occupancy as part of state.
Evidence 2B · LF52 the cart was a board cell Schema w/ Fable 10/10 · Opus 4/10
Both models recognized peg solitaire and learned that a cart moved along tracks. The decisive issue was how the two mechanisms composed. Fable first excluded the useful interaction too, then drove the cart to an exact docking coordinate and treated that moment as an observation point.
Fable Two object systems become one transition graph 10 / 10 levels
initial inference false negative a peg can only be selected if it has ≥1 legal jump, meaning c5-over-c6-into-pipe/box is NOT legal.
cart discovery observation An arrow moved the box along the rail. Fable then drove it to the dock, explicitly expecting the docking step to reveal how cart and board composed.
at the dock boundary revision The cart docked — with a surprise: the board reflowed! ... cart core ... sits flush as an extra cell next to c6.
world model v5 code revision Fixed cells and mobile cart cores enter the same cell map: def _find_cells(world): cells = detect_fixed_cells(world) for x, y in _find_carts(world): cells[(x, y)] = _cart_kind(world, x, y) return cells
transfer result The ordinary jump generator now handled jump-in, transport, and jump-out. Fable reused the representation across later multi-cart and scrolling levels.
Opus A related probe tests the wrong causal role eventual convergence
early test probe Opus asked whether a peg could jump over the cart. The result correctly rejected “cart as middle piece,” but did not test “cart as landing cell.”
~100 turns later test repair Prior test clicked c6 not c5 ... c5 over c6 lands EXACTLY at ... box dock ... THIS combo untested.
exact geometry observation BREAKTHROUGH! ... a color-2 landing marker appeared on the box ... the box IS a valid peg landing! Opus then revised to the same transport mechanism.
LF52, level 2 — Schema w/ Fable 5 on the left tests the cart at the exact docking geometry; Opus 4.8 Max on the right reaches the same composition only after leaving that combination untested much longer. Game image left, reasoning trace right in both playbacks.
Observed pattern: a negative experiment rejects only the mechanism-instance combination actually tested. Fable found the useful composition earlier by testing the cart at the exact source–middle–landing geometry.
Evidence 2C · SB26 generality appears as structured revision SCHEMA w/ Fable 135 vs Opus 456 actions
Both models discovered a DFS-like rule after Level 1 and both eventually solved all eight levels. This pair separates “stating a general idea” from maintaining a reusable coded abstraction that absorbs later variation.
Fable Recursive mechanism with later extensions 8 / 8 · 135 actions
Level 1 structural hypothesis Hypothesis: the code reads depth-first ... Let me generalize the model with boxes/portals/DFS target assignment. Fable submitted the complete generated assignment, making the hypothesis strongly falsifiable. The level cleared.
world model v5 code abstraction def traverse(box): if box in visited: return visited.add(box) for kind, obj in sorted(elements_inside(box)): if kind == "marker": assign_next_target(obj) else: for child in boxes_for_portal(obj): traverse(child)
Levels 3–6 structured revisions Fable still changed the model: portals became movable; a global visited set became a path-based cycle guard; depth-three nesting appeared. The stable part was the causal schema—hollow objects reference containers, and traversal generates assignments.
later levels compression After the first DFS hypothesis, later level increments were approximately 15 / 15 / 15 / 17 / 19 / 17 / 28 actions.
Opus Same first idea, less robust transfer 8 / 8 · 456 actions
Level 1 confirmation Level 1 cleared! The DFS-traversal target rule is confirmed.
later variation hypothesis sweeps Opus repeatedly switched from structure to assignment conventions such as contiguous color blocks and grid reading order when new shapes appeared.
Level 6 missing state 16 turns stuck on L6 ... The missing variable was tile shape — TEST3's colors were right all along, but the two hollow tiles must go in the middle column slots.
SB26 — Schema w/ Fable 5 on the left reuses the DFS abstraction on level 2 in about 15 actions; Opus 4.8 Max on the right shows the later level-6 grind before recovering the missing tile-shape variable. Game image left, reasoning trace right in both playbacks.
Observed pattern: a general mechanism is not one that never changes. It is one whose revisions preserve earlier explanatory machinery and compress the cost of new levels.
Summary. The harness and the underlying model affect efficiency at distinct stages:
The executable harness reduces the cost of using a theory. It makes the theory persistent, exactly verifiable, and searchable. This is the source of the efficiency pattern observed relative to the human reference.
The underlying model determines the cost of discovering a useful theory. Paired runs sometimes converge on the same representation through markedly different trajectories. Fable more often makes the decisive representational revision earlier and therefore reaches an executable solution with fewer environment actions.
Search is only complete relative to the world model it operates over. Once the missing object, state variable, or transition is represented, the existing verifier and planner are often enough. If observations do not distinguish the right representation, the same machinery can verify and exhaustively search the wrong one.
This is a new beginning
ARC‑AGI‑3 is an important benchmark in a rapidly advancing field. When it launched in March, the leading frontier agent scored just 0.51%. By July, the best official Sol Max result had reached 13.33% on Public and 7.78% on Semi‑private, while self-reported results climbed as high as 58.12% mean per-game RHAE.
Our self-reported 98.98% continues this trajectory rather than breaking from it. The key ingredients were already emerging: frontier models capable of adapting to novel environments, coding-agent harnesses, and programmatic world models. Schema is the system that brings them together.
We read a saturated ARC‑3 as the new beginning: mechanism discovery as a general capability — grounding the causal structure of a world through the agentic loop of action and perception, in environments far richer than a 64×64 grid. This is where we are heading to.