【论文阅读】Agent 记忆机制（62）：DCM-Agent——用双簇记忆化解优化问题的多范式冲突

文章目录

前言
零、论文基本信息
一、背景与问题：为什么优化问题需要"双簇记忆"
- [1. 从自然语言到可执行解的两次映射](#1. 从自然语言到可执行解的两次映射)
- [2. 一对多结构带来的认知干扰](#2. 一对多结构带来的认知干扰)
- [3. 为什么普通 RAG 仍然不够](#3. 为什么普通 RAG 仍然不够)
[二、相关工作：DCM-Agent 与现有优化 Agent 的差别](#二、相关工作：DCM-Agent 与现有优化 Agent 的差别)
- [1. Prompt 与 Multi-Agent 优化建模](#1. Prompt 与 Multi-Agent 优化建模)
- [2. 搜索式推理](#2. 搜索式推理)
- [3. Fine-tuning 专用优化模型](#3. Fine-tuning 专用优化模型)
- [4. Retrieval-Augmented Reasoning](#4. Retrieval-Augmented Reasoning)
[三、DCM-Agent 方法总览](#三、DCM-Agent 方法总览)
四、节点级记忆：先把经验按"成功方式"分层
- [1. 为什么失败经验不能直接丢弃](#1. 为什么失败经验不能直接丢弃)
- [2. Type A、B、C](#2. Type A、B、C)
- - [Type A：Always Correct](#Type A：Always Correct)
  - [Type B：Recovered](#Type B：Recovered)
  - [Type C：Persistent Failure](#Type C：Persistent Failure)
- [3. 将完整解答拆成 Modeling 与 Coding](#3. 将完整解答拆成 Modeling 与 Coding)
- [4. 例子：整数袋数为什么属于 Modeling Pitfall](#4. 例子：整数袋数为什么属于 Modeling Pitfall)
五、簇级演化：从单个案例变成可迁移知识
- [1. Cluster Assignment：Embedding 召回 + LLM 复核](#1. Cluster Assignment：Embedding 召回 + LLM 复核)
- [2. Knowledge Update：以批量触发避免被单个样本带偏](#2. Knowledge Update：以批量触发避免被单个样本带偏)
- [3. Approach、Checklist、Pitfall 是三种不同的控制信号](#3. Approach、Checklist、Pitfall 是三种不同的控制信号)
六、二部图：显式保存建模与代码的兼容关系
- [1. 图结构定义](#1. 图结构定义)
- [2. 为什么不是一个统一聚类](#2. 为什么不是一个统一聚类)
- [3. 二部图仍然不是"正确性证明"](#3. 二部图仍然不是“正确性证明”)
七、双重检索：同时找相似实例和抽象范式
- [1. Instance-Level Retrieval](#1. Instance-Level Retrieval)
- [2. Cluster-Level Retrieval](#2. Cluster-Level Retrieval)
- [3. 合并候选建模簇](#3. 合并候选建模簇)
- [4. 从建模簇沿图找到代码簇](#4. 从建模簇沿图找到代码簇)
[八、Memory-Augmented Inference：生成、验证、修复与回退](#八、Memory-Augmented Inference：生成、验证、修复与回退)
- [1. Modeling Generation](#1. Modeling Generation)
- [2. Modeling Verification](#2. Modeling Verification)
- [3. Coding Generation 与 Verification](#3. Coding Generation 与 Verification)
- [4. Execution 与知识引导修复](#4. Execution 与知识引导修复)
- [5. Backtracking：代码修不好时切换整条路径](#5. Backtracking：代码修不好时切换整条路径)
九、一个完整例子：数值更优为什么反而是错解
十、实验设置
- [1. 七个数据集](#1. 七个数据集)
- [2. Backbone 与 Baseline](#2. Backbone 与 Baseline)
- [3. 严格端到端正确率](#3. 严格端到端正确率)
十一、主实验：不同模型规模上的完整结果
- [1. Qwen3-8B 与 Qwen3-30B](#1. Qwen3-8B 与 Qwen3-30B)
- [2. Qwen3-235B](#2. Qwen3-235B)
- [3. DeepSeek-V3.2 与 GPT-5.1](#3. DeepSeek-V3.2 与 GPT-5.1)
- [4. 主结果应该怎样理解](#4. 主结果应该怎样理解)
十二、效率：结构化路径比树搜索快多少
[十三、Memory Budget：更多节点是否持续有效](#十三、Memory Budget：更多节点是否持续有效)
[十四、Knowledge Inheritance：大模型记忆能否教小模型](#十四、Knowledge Inheritance：大模型记忆能否教小模型)
- [1. Qwen3-8B 使用不同模型构建的记忆](#1. Qwen3-8B 使用不同模型构建的记忆)
- [2. Qwen3-235B 使用不同模型构建的记忆](#2. Qwen3-235B 使用不同模型构建的记忆)
十五、簇数量分析：强模型为什么能分得更细
十六、双簇消融：建模簇与代码簇谁更重要
[十七、参数敏感性：K、N、M 分别控制什么](#十七、参数敏感性：K、N、M 分别控制什么)
- [1. K K K：信息不足与检索噪声之间的平衡](#1. K K K：信息不足与检索噪声之间的平衡)
- [2. N N N：过拟合单例与延迟合成之间的平衡](#2. N N N：过拟合单例与延迟合成之间的平衡)
- [3. M M M：更多备选路径带来收益，但成本增加](#3. M M M：更多备选路径带来收益，但成本增加)
十八、失败模式与反例
- [1. 最强记忆不一定适合最小模型](#1. 最强记忆不一定适合最小模型)
- [2. 更多检索并不总是更好](#2. 更多检索并不总是更好)
- [3. 共现边可能继承数据偏差](#3. 共现边可能继承数据偏差)
- [4. 可执行仍不等于语义正确](#4. 可执行仍不等于语义正确)
- [5. 所有候选路径都不在图中时会失败](#5. 所有候选路径都不在图中时会失败)
- [6. 错误主要集中在代码修复还是模型回退，论文没有拆开报告](#6. 错误主要集中在代码修复还是模型回退，论文没有拆开报告)
[十九、与 Agent Memory 系列方法的横向比较](#十九、与 Agent Memory 系列方法的横向比较)
- [1. 与 A-MEM 的关系](#1. 与 A-MEM 的关系)
- [2. 与 MAGMA 的关系](#2. 与 MAGMA 的关系)
- [3. 与 CFGM 的关系](#3. 与 CFGM 的关系)
- [4. 与 ReMemR1 / Mem²Evolve 的关系](#4. 与 ReMemR1 / Mem²Evolve 的关系)
[二十、对 Coding Agent、Tool Agent 与 Multi-Agent 的启发](#二十、对 Coding Agent、Tool Agent 与 Multi-Agent 的启发)
- [1. Coding Agent：把设计决策和实现模式分开记](#1. Coding Agent：把设计决策和实现模式分开记)
- [2. Tool Agent：将"意图规划"和"工具调用"解耦](#2. Tool Agent：将“意图规划”和“工具调用”解耦)
- [3. Multi-Agent：不同角色给出的是不同范式，而非简单投票](#3. Multi-Agent：不同角色给出的是不同范式，而非简单投票)
- [4. 结构化负经验比失败日志更有价值](#4. 结构化负经验比失败日志更有价值)
二十一、局限性
- [1. 作者明确承认的局限：初始化成本](#1. 作者明确承认的局限：初始化成本)
- [2. 进一步的局限](#2. 进一步的局限)
- - [2.1 缺少初始化成本的实测数字](#2.1 缺少初始化成本的实测数字)
  - [2.2 二部图边权过于简单](#2.2 二部图边权过于简单)
  - [2.3 聚类和知识合成都依赖 LLM](#2.3 聚类和知识合成都依赖 LLM)
  - [2.4 500 条自建问题由共同作者标注](#2.4 500 条自建问题由共同作者标注)
  - [2.5 Baseline 公平性与复现细节仍需代码核对](#2.5 Baseline 公平性与复现细节仍需代码核对)
  - [2.6 只验证了优化领域的二层结构](#2.6 只验证了优化领域的二层结构)
二十二、我的理解和启发
- [1. DCM-Agent 的本质是把"答案记忆"改成"路径记忆"](#1. DCM-Agent 的本质是把“答案记忆”改成“路径记忆”)
- [2. 多范式歧义不应该靠"融合"解决](#2. 多范式歧义不应该靠“融合”解决)
- [3. Approach、Checklist、Pitfall 对应三种认知动作](#3. Approach、Checklist、Pitfall 对应三种认知动作)
- [4. Knowledge Inheritance 提示了一个新的模型压缩方向](#4. Knowledge Inheritance 提示了一个新的模型压缩方向)
- [5. 下一步应从共现图走向因果验证图](#5. 下一步应从共现图走向因果验证图)
- [6. 在线闭环是这项工作的自然下一步](#6. 在线闭环是这项工作的自然下一步)
二十三、总结
参考资料

前言

前面讨论 CFGM 时，我们看到了一种"从经验采集到在线纠错"的记忆设计：先提高轨迹质量，再提炼 Tips，最后在异常发生时利用短期轨迹修正计划。

但当 Agent 面对数学优化问题时，记忆系统还会遇到另一种更隐蔽的困难：历史经验可能都没有错，却会因为属于不同求解范式而互相干扰。

例如，一个生产规划问题同时包含：

资源数量与收益最大化，看起来适合整数线性规划（ILP）；
"必须是 5 的整数倍"之类逻辑约束，看起来适合约束规划（CP）；
多阶段决策和状态转移，又容易让人想到动态规划（DP）。

这些线索都与问题有关，却不能被不加区分地混进同一条推理路径。更麻烦的是，即使数学建模范式选对了，代码实现仍可能选错求解器、变量类型或 API。反过来，某种代码模板写得非常熟练，也不能证明它背后的数学模型是正确的。

如果记忆库只是按题目语义检索"相似案例"，Agent 就可能把两类本应分开的知识混为一谈：

Modeling Memory： 问题应该怎样抽象，变量、目标函数和约束应该如何定义；
Coding Memory： 这个模型应怎样映射到 Gurobi、OR-Tools、PuLP、SciPy 或 NetworkX 的可执行代码。

DCM-Agent（Dual-Cluster Memory Agent）正是围绕这个结构性歧义展开。它不把历史解答放进一个统一经验簇，而是把每条经验拆成"建模逻辑"和"代码实现"，分别形成 Modeling Cluster 与 Coding Cluster，再用加权二部图记录两类簇之间被历史成功验证过的配对关系。

在每个簇内部，它又把经验蒸馏为三类结构化知识：

Approach： 应该怎样解决；
Checklist： 应该验证什么；
Pitfall： 应该避免什么。

推理时，Agent 不再只召回一个答案，而是检索一组"建模簇 → 代码簇"的候选路径，并沿着 Generate--Verify--Repair--Backtrack 流程逐条尝试。

因此，这篇论文的唯一核心增量可以概括为：

DCM-Agent 将优化问题经验解耦为独立的建模簇和代码簇，并用二部图显式保存二者的可靠组合，使 Agent 能在多个相互干扰的求解范式之间检索、验证、修复和回退。

它真正改变的不是"记忆里存了更多解题知识"，而是记忆怎样表示一对多的解题路径。

零、论文基本信息

论文名称： Dual-Cluster Memory Agent: Resolving Multi-Paradigm Ambiguity in Optimization Problem Solving

发表平台： ACL 2026 Main Conference（Long Papers），pp. 5895--5908

代码仓库： https://github.com/LYMQY/OPS-Mem

作者： Xinyu Zhang、Yuchen Wan、Boxuan Zhang、Zesheng Yang、Lingling Zhang、Bifan Wei、Jun Liu

一、背景与问题：为什么优化问题需要"双簇记忆"

1. 从自然语言到可执行解的两次映射

论文把自动求解优化问题形式化为三个空间之间的映射：

问题空间 X \mathcal{X} X：自然语言描述；
建模空间 M \mathcal{M} M：变量、目标和约束组成的数学模型；
代码空间 C \mathcal{C} C：调用求解器的可执行程序。

完整输出为：

y ^ = E ( h ψ ( c ∣ m ) ⏟ Coding ∘ g ϕ ( m ∣ x ) ⏟ Modeling ) , \hat{y}=\mathcal{E}\left( \underbrace{h_{\psi}(c\mid m)}{\text{Coding}} \circ \underbrace{g{\phi}(m\mid x)}_{\text{Modeling}} \right), y^=E Coding hψ(c∣m)∘Modeling gϕ(m∣x) ,

其中：

x ∈ X x\in\mathcal{X} x∈X 是自然语言问题；
g ϕ g_{\phi} gϕ 将问题转换为建模逻辑 m ^ \hat m m^；
h ψ h_{\psi} hψ 将建模逻辑转换为代码 c ^ \hat c c^；
E ( ⋅ ) \mathcal{E}(\cdot) E(⋅) 是实际运行代码的求解器环境；
y ^ \hat y y^ 包含执行结果、数学模型和代码。

这个分解很重要。很多优化题的错误并不发生在代码层，而是更早的建模层。例如把"袋数"定义为连续变量，即使代码能够运行、求解器也返回最优值，答案仍然不符合现实。

2. 一对多结构带来的认知干扰

同一个 x x x 往往不只对应一个 m m m，同一个 m m m 也可能有多种 c c c：

x → { m 1 , m 2 , ... , m p } → { c 11 , c 12 , ... , c p q } . x\rightarrow\{m_1,m_2,\ldots,m_p\} \rightarrow \{c_{11},c_{12},\ldots,c_{pq}\}. x→{m1,m2,...,mp}→{c11,c12,...,cpq}.

不同路径并非完全互换：

LP 模型不能表达某些离散逻辑；
MIP 可以处理整数变量，但求解成本可能更高；
CP-SAT 擅长组合约束，却不适合所有连续问题；
SciPy 的连续优化接口与 Gurobi、PuLP 的建模方式不同；
NetworkX 适用于具有明确图结构的问题。

如果只按文本相似度召回历史题，检索结果可能同时包含多个范式。模型看到的不是帮助，而是一组方向相反的暗示。

先看论文用于说明这一矛盾的例子。

Figure 1：一个生产规划问题可以由不同算法范式形式化。 资源最大化线索指向 ILP，整数倍和逻辑约束指向 CP，多阶段依赖又可能指向 DP；每种范式具有不同的 Approach、Checklist 和 Pitfall。

这张图支持论文最基本的问题设定：优化问题中的歧义不是"没有相关知识"，而是相关知识过多且存在结构冲突。

3. 为什么普通 RAG 仍然不够

普通 RAG 可以找到语义相近的问题，但很难回答三个更细的问题：

过去案例相似的是业务描述，还是数学结构？
建模方法相似，是否意味着代码实现也兼容？
如果当前路径失败，应该修改代码，还是放弃整个建模范式？

DCM-Agent 的答案是：将建模与代码分别聚类，再通过历史共现关系连接。这样，失败时系统能够判断应在当前 Coding Cluster 内修复，还是退回候选队列切换整条建模---编码路径。

二、相关工作：DCM-Agent 与现有优化 Agent 的差别

1. Prompt 与 Multi-Agent 优化建模

OptiMUS 等方法把问题理解、变量抽取、约束生成和代码验证拆给多个角色。优点是流程清楚，缺点是知识主要存在于固定 Prompt 和当前上下文中，历史成功与失败并没有形成可演化的外部结构。

2. 搜索式推理

AF-MCTS 使用 Monte Carlo Tree Search 逐步识别变量、约束和目标；OptiTree 则将复杂问题分解为子问题并组织树状推理。搜索可以覆盖更多候选，但时间开销较高，而且树中的每条路径仍需要可靠的范式知识来判断。

DCM-Agent 用历史簇和二部图缩小候选空间。它并没有消灭搜索，而是把搜索从开放式 token 分支转成少量结构化的"Modeling Cluster → Coding Cluster"路径。

3. Fine-tuning 专用优化模型

ORLM、FOARL、SIRL 等工作通过领域数据训练或强化学习，把优化建模知识写进参数。它们适合形成专用能力，但训练成本高，也容易在多个相似范式之间机械套用模板。

DCM-Agent 不更新参数，属于 training-free 外部记忆方法。记忆可独立构建、转移和替换，这为后文的"knowledge inheritance"提供了前提。

4. Retrieval-Augmented Reasoning

ReAct、Retrieval-Augmented Thoughts 和 OptiTree 已经证明，外部案例可以辅助长链推理与验证。但 DCM-Agent 进一步提出：优化任务的检索单元不应该只是完整问题或完整解答，而应该同时存在：

instance-level 相似案例；
cluster-level 抽象范式；
modeling--coding 配对路径；
Approach、Checklist、Pitfall 三种功能不同的知识。

三、DCM-Agent 方法总览

完整框架分为两个阶段：

Dual-Cluster Memory Construction： 从历史问题---解答轨迹构建双簇记忆；
Memory-Augmented Inference： 对新问题检索候选路径并执行生成、验证、修复和回退。

Figure 2：DCM-Agent 方法总览。 左侧先把历史轨迹分为 Always Correct、Recovered 和 Persistent Failure，并提取 Approach、Checklist、Pitfall；中间分别构建 Modeling Cluster 与 Coding Cluster，并以加权二部图连接；右侧对新问题执行双重检索、路径排序和 Generate--Verify--Repair--Backtrack 推理。

整个框架可以压缩为：

D r a w → stratify + decompose ( C M , C C , G ) → dual retrieval Q → solve + verify + repair y ^ . \mathcal{D}_{raw} \xrightarrow{\text{stratify + decompose}} (\mathcal{C}^{M},\mathcal{C}^{C},G) \xrightarrow{\text{dual retrieval}} \mathcal{Q} \xrightarrow{\text{solve + verify + repair}} \hat y. Drawstratify + decompose (CM,CC,G)dual retrieval Qsolve + verify + repair y^.

其中 C M \mathcal{C}^{M} CM 是 Modeling Clusters， C C \mathcal{C}^{C} CC 是 Coding Clusters， G G G 是连接二者的二部图， Q \mathcal{Q} Q 是按优先级排列的候选求解路径。

四、节点级记忆：先把经验按"成功方式"分层

1. 为什么失败经验不能直接丢弃

一条始终成功的轨迹与一条失败后修复成功的轨迹，提供的信息不同：

始终成功说明一条稳定的标准路径；
修复成功暴露了成功和失败之间的决策边界；
持续失败说明该范式与问题可能存在根本不匹配。

因此，论文将 500 条建库问题的多次求解轨迹分成三类。

2. Type A、B、C

Type A：Always Correct

多次尝试都能正确求解。它们被视为 canonical patterns，适合提取标准 Approach 和 Checklist。

Type B：Recovered

第一次失败，但重试后成功。它同时包含正负信号：成功部分说明正确路径，转折部分则揭示具体错误及修复方式。

Type C：Persistent Failure

超过最多 3 轮仍未成功。它们不被当成"无用垃圾"，而用于描述范式不适配、约束遗漏、变量类型错误等 Pitfall。

三种类型与知识层的对应关系如下。

知识层来源内容 ϕ a p p r o a c h Type A + Type B 求解模板与逻辑步骤：怎样解 ϕ c h e c k l i s t Type A + Type B 有效性标准与边界检查：检查什么 ϕ p i t f a l l Type B + Type C 常见错误与约束冲突：避免什么 \begin{array}{c|c|l} \textbf{知识层} & \textbf{来源} & \textbf{内容} \\ \hline \phi^{approach} & \text{Type A + Type B} & \text{求解模板与逻辑步骤：怎样解} \\ \phi^{checklist} & \text{Type A + Type B} & \text{有效性标准与边界检查：检查什么} \\ \phi^{pitfall} & \text{Type B + Type C} & \text{常见错误与约束冲突：避免什么} \end{array} 知识层ϕapproachϕchecklistϕpitfall来源Type A + Type BType A + Type BType B + Type C内容求解模板与逻辑步骤：怎样解有效性标准与边界检查：检查什么常见错误与约束冲突：避免什么

Table 1：样本类型到指导知识层的映射。 成功样本用于 Approach 与 Checklist，失败或修复样本用于 Pitfall；Recovered 同时连接正向方案和失败边界。

3. 将完整解答拆成 Modeling 与 Coding

对第 n n n 条历史经验，DCM-Agent 将解答拆成：

y n → ( m n , c n ) , y_n\rightarrow(m_n,c_n), yn→(mn,cn),

并分别生成 embedding：

e n m = E m b e d ( m n ) , e n c = E m b e d ( c n ) . e_n^m=Embed(m_n),\qquad e_n^c=Embed(c_n). enm=Embed(mn),enc=Embed(cn).

同时提取节点级知识：

Φ n = ⟨ ϕ n a p p r o a c h , ϕ n c h e c k l i s t , ϕ n p i t f a l l ⟩ . \Phi_n= \left\langle \phi_n^{approach}, \phi_n^{checklist}, \phi_n^{pitfall} \right\rangle. Φn=⟨ϕnapproach,ϕnchecklist,ϕnpitfall⟩.

Φ n \Phi_n Φn 仍然是针对单个案例的局部记忆。后续聚类的目的，是把多个相似案例压缩成稳定的 cluster-level knowledge。

4. 例子：整数袋数为什么属于 Modeling Pitfall

"购买多少袋饲料"隐含离散性。如果 Agent 使用 NumVar 和连续 LP 求解器，程序可能顺利执行，却得到 2.05 袋和 0.57 袋。

这不是普通 syntax error，而是建模语义错误。因此节点记忆应分别记录：

Modeling Approach：把袋数表示为非负整数决策变量；
Modeling Checklist：检查现实对象是否允许小数；
Modeling Pitfall：不要因为目标和约束是线性的，就自动采用连续 LP；
Coding Approach：使用 CBC/MIP 或相应整数求解器；
Coding Checklist：确认代码使用 IntVar 而不是 NumVar。

同一错误跨越建模和代码两层，但两层责任不同，这正是双簇拆分的必要性。

五、簇级演化：从单个案例变成可迁移知识

1. Cluster Assignment：Embedding 召回 + LLM 复核

对新节点的 Modeling 部分，系统先用 e n m e_n^m enm 与现有簇中心 μ k M \mu_k^M μkM 做 Top-K 检索；Coding 部分用 e n c e_n^c enc 与 μ k C \mu_k^C μkC 检索。

仅凭 embedding 相似度可能把表面相近但数学结构不同的案例合并，因此候选簇还要经过 LLM verifier：

C c a n d M = T o p K ( e n m , { μ k M } ) , C_{cand}^{M}=TopK(e_n^m,\{\mu_k^M\}), CcandM=TopK(enm,{μkM}),

C n M = { C j M , L L M v e r i f y ( m n , C j M ) = m a t c h , C n e w M , 没有候选簇匹配 . C_n^M= \begin{cases} C_j^M,&LLM_{verify}(m_n,C_j^M)=match,\\ C_{new}^M,&\text{没有候选簇匹配}. \end{cases} CnM={CjM,CnewM,LLMverify(mn,CjM)=match,没有候选簇匹配.

Coding Cluster 使用同样流程，但独立分配。于是一个节点最终连接到一对簇 ( C i M , C j C ) (C_i^M,C_j^C) (CiM,CjC)。

2. Knowledge Update：以批量触发避免被单个样本带偏

每个簇维护三类广义知识：

K = ⟨ K a p p r o a c h , K c h e c k l i s t , K p i t f a l l ⟩ . \mathcal{K}= \left\langle \mathcal{K}^{approach}, \mathcal{K}^{checklist}, \mathcal{K}^{pitfall} \right\rangle. K=⟨Kapproach,Kchecklist,Kpitfall⟩.

当簇累计 N N N 个新节点后，系统触发更新：

K ( t + 1 ) = L L M s y n t h ( K ( t ) ∪ ⋃ j = 1 N Φ n j ) . \mathcal{K}^{(t+1)}= LLM_{synth} \left( \mathcal{K}^{(t)} \cup \bigcup_{j=1}^{N}\Phi_{n_j} \right). K(t+1)=LLMsynth(K(t)∪j=1⋃NΦnj).

这里的输入包含旧知识 K ( t ) \mathcal{K}^{(t)} K(t) 和新批次节点知识 Φ n j \Phi_{n_j} Φnj，输出是去重、概括后的新簇知识。

为什么不来一条经验就更新一次？因为单个案例可能是极端样本。批量阈值让 LLM 在多个证据间寻找稳定模式。实验显示默认 N = 5 N=5 N=5 最好； N = 1 N=1 N=1 容易过拟合， N = 10 N=10 N=10 又会让知识更新过慢。

3. Approach、Checklist、Pitfall 是三种不同的控制信号

这三类知识并非普通摘要的三个字段：

K a p p r o a c h \mathcal{K}^{approach} Kapproach 在生成阶段提供正向路线；
K c h e c k l i s t \mathcal{K}^{checklist} Kchecklist 在验证阶段充当范式特定的判据；
K p i t f a l l \mathcal{K}^{pitfall} Kpitfall 在执行失败后提供定向修复线索。

换句话说，结构化记忆不仅保存内容，还预先指定了每类内容的使用时机。

六、二部图：显式保存建模与代码的兼容关系

1. 图结构定义

DCM-Agent 将两类簇构造成加权二部图：

G = ( V M , V C , E ) , G=(V^M,V^C,E), G=(VM,VC,E),

其中：

V M V^M VM 是 Modeling Cluster 节点集合；
V C V^C VC 是 Coding Cluster 节点集合；
E E E 只连接两侧节点；
w i j w_{ij} wij 表示 C i M C_i^M CiM 与 C j C C_j^C CjC 在历史经验中的共现次数。

每加入一个映射到 ( C i M , C j C ) (C_i^M,C_j^C) (CiM,CjC) 的经验节点，边权更新：

w i j ← w i j + 1. w_{ij}\leftarrow w_{ij}+1. wij←wij+1.

强边表示这套数学建模逻辑与代码实现方式在历史中多次共同出现，是推理阶段优先选择的"已验证路径"。

2. 为什么不是一个统一聚类

统一聚类会把建模与代码绑定成不可拆分的模板，而现实中存在多对多关系：

同一个 MIP 建模簇可用 Gurobi、PuLP/CBC 或 OR-Tools；
同一种 Gurobi 代码架构可以实现设施选址、调度和资源分配等多个建模簇；
某些建模---代码配对频繁成功，另一些虽然理论可行，却容易触发接口或表达问题。

二部图保留了这种组合空间，又利用边权避免推理时进行笛卡尔积式盲搜。

3. 二部图仍然不是"正确性证明"

w i j w_{ij} wij 是共现频率，不是数学上的兼容概率，也没有按任务难度、样本质量或近期成功率加权。一条强边可能只是训练数据中出现得多。

因此，论文仍需要 Checklist 验证和代码执行器。二部图提供 prior，而不是替代求解器验证。

七、双重检索：同时找相似实例和抽象范式

1. Instance-Level Retrieval

对新问题 x n e w x_{new} xnew，先编码得到 e n e w e_{new} enew，再从历史节点中检索最相似的 K K K 个实例：

H = arg ⁡ max ⁡ K { s i m ( e n e w , e i ) ∣ x i ∈ D } . H=\arg\max_K \left\{ sim(e_{new},e_i)\mid x_i\in\mathcal{D} \right\}. H=argKmax{sim(enew,ei)∣xi∈D}.

这一通道擅长捕捉局部语义和具体题型，例如"混合配料""设施选址"或"车辆路径"。

2. Cluster-Level Retrieval

另一通道直接比较新问题与 Modeling Cluster 中心：

S c l u s t e r = arg ⁡ max ⁡ K { s i m ( e n e w , μ k M ) } . S_{cluster}=\arg\max_K \left\{ sim(e_{new},\mu_k^M) \right\}. Scluster=argKmax{sim(enew,μkM)}.

它寻找的是更抽象的算法范式，可以避免新题与某个历史题表面词汇不同而漏召回。

3. 合并候选建模簇

系统将两条检索路径合并：

R = { C M ( x i ) ∣ x i ∈ H } ∪ S c l u s t e r . R= \{C^M(x_i)\mid x_i\in H\} \cup S_{cluster}. R={CM(xi)∣xi∈H}∪Scluster.

这相当于同时回答：

哪些具体历史题与当前问题相似？
哪些抽象建模范式与当前问题相似？

4. 从建模簇沿图找到代码簇

对每个 C i M ∈ R C_i^M\in R CiM∈R，沿二部图取边权最高的 Top-K Coding Clusters，组成候选路径池：

P = { p = ( C i M , C j C ) } . \mathcal{P}= \left\{ p=(C_i^M,C_j^C) \right\}. P={p=(CiM,CjC)}.

随后由 LLM selector 根据新问题排序，保留 Top-M 路径：

Q = T o p M p ∈ P ( L L M s e l e c t ( p ∣ x n e w ) ) . \mathcal{Q}=TopM_{p\in\mathcal{P}} \left(LLM_{select}(p\mid x_{new})\right). Q=TopMp∈P(LLMselect(p∣xnew)).

Q = $p 1 , p 2 , ... , p M$ \mathcal{Q}= $p_1,p_2,\\ldots,p_M$ Q= $p1,p2,...,pM$ 不是一组完整答案，而是按优先级排列的求解计划。

八、Memory-Augmented Inference：生成、验证、修复与回退

1. Modeling Generation

对候选路径 p t = ( C i M , C j C ) p_t=(C_i^M,C_j^C) pt=(CiM,CjC)，先用 Modeling Cluster 的 Approach 生成数学模型：

m ^ r a w = L L M g e n ( x n e w ∣ K i a p p r o a c h ) . \hat m_{raw}=LLM_{gen} (x_{new}\mid\mathcal{K}_i^{approach}). m^raw=LLMgen(xnew∣Kiapproach).

Approach 提供的不是某条历史答案，而是这个簇总结出的变量设计、目标形式和约束结构。

2. Modeling Verification

生成后立即用 Modeling Checklist 验证：

m ^ = L L M v e r i f y ( m ^ r a w ∣ K i c h e c k l i s t ) . \hat m=LLM_{verify} (\hat m_{raw}\mid\mathcal{K}_i^{checklist}). m^=LLMverify(m^raw∣Kichecklist).

检查内容可以包括：变量是否应为整数、是否遗漏容量约束、目标方向是否正确、单位是否一致、线性假设是否成立。

这比通用的"检查答案是否正确"更具体，因为 Checklist 与当前 Modeling Cluster 绑定。

3. Coding Generation 与 Verification

得到模型后，系统使用 Coding Cluster 的 Approach 生成代码，再用 Coding Checklist 检查：

c ^ r a w = L L M g e n ( m ^ ∣ K j a p p r o a c h ) , \hat c_{raw}=LLM_{gen} (\hat m\mid\mathcal{K}_j^{approach}), c^raw=LLMgen(m^∣Kjapproach),

c ^ = L L M v e r i f y ( c ^ r a w ∣ K j c h e c k l i s t ) . \hat c=LLM_{verify} (\hat c_{raw}\mid\mathcal{K}_j^{checklist}). c^=LLMverify(c^raw∣Kjchecklist).

这里关注的是求解器初始化、变量 API、约束表达、边界、返回值解析和可执行性。

4. Execution 与知识引导修复

代码交给求解器环境：

( r e s u l t , e r r o r ) = E ( c ^ ) . (result,error)=\mathcal{E}(\hat c). (result,error)=E(c^).

若执行失败，系统结合错误信息、Coding Pitfall 和 Checklist 修复：

c ^ f i x e d = L L M f i x ( c ^ , e r r o r ∣ K j p i t f a l l , K j c h e c k l i s t ) . \hat c_{fixed}=LLM_{fix} (\hat c,error\mid \mathcal{K}_j^{pitfall}, \mathcal{K}_j^{checklist}). c^fixed=LLMfix(c^,error∣Kjpitfall,Kjchecklist).

默认最多进行 2 次修复。相比盲目 Debug，这一步将错误放进当前代码范式的常见失败模式中解释。

5. Backtracking：代码修不好时切换整条路径

如果当前路径修复失败，系统不会无限重复，而是进入 p t + 1 p_{t+1} pt+1：

p t → f a i l e d p t + 1 . p_t\xrightarrow{failed}p_{t+1}. ptfailed pt+1.

这一步是 DCM-Agent 处理 multi-paradigm ambiguity 的关键。失败可能意味着当前代码有 bug，也可能意味着整个 Modeling Cluster 就不适合当前问题。路径级回退允许系统从 MIP 切换到 CP、图算法或其他候选，而不是困在局部方案中。

九、一个完整例子：数值更优为什么反而是错解

Figure 6：离散饲料配比任务中的 Baseline 与 DCM-Agent。 Baseline 使用连续 LP 求解器 GLOP 和 NumVar，得到成本更低但现实不可行的 2.05、0.57 袋；DCM-Agent 使用 CBC 与 IntVar，得到 0、2 袋和 70 美元的可行整数解。

这个案例揭示了优化 Agent 与普通代码 Agent 的差异：程序成功运行不等于问题被正确求解。

Baseline 得到 60.80 美元，看起来优于 DCM-Agent 的 70 美元，但它允许购买小数袋，违反现实语义。论文称之为 "deceptive optimality"------数值目标更漂亮，建模却根本不可行。

DCM-Agent 的双簇记忆在这里分别发挥作用：

Modeling Cluster 识别"袋数"对应整数决策；
Modeling Checklist 检查离散对象是否被连续化；
Coding Cluster 选择支持 MIP 的 CBC；
Coding Checklist 检查 IntVar；
Pitfall 提醒不要把所有线性表达式都交给连续 LP。

这个例子很好地支撑了论文核心增量，因为错误恰好跨越数学语义和代码实现两个层次。

十、实验设置

1. 七个数据集

论文覆盖七类优化建模基准：

数据集样本数定位 NL4Opt 230 自然语言线性规划 ComplexLP 211 复杂线性规划子集 NLP4LP 242 自然语言到 LP/MILP OptiBench 605 综合优化建模 OptMATH 166 高难度数学优化 IndustryOR 100 工业运筹问题 ComplexOR 18 复杂现实运筹问题 \begin{array}{l|r|l} \textbf{数据集} & \textbf{样本数} & \textbf{定位} \\ \hline \text{NL4Opt} & 230 & \text{自然语言线性规划} \\ \text{ComplexLP} & 211 & \text{复杂线性规划子集} \\ \text{NLP4LP} & 242 & \text{自然语言到 LP/MILP} \\ \text{OptiBench} & 605 & \text{综合优化建模} \\ \text{OptMATH} & 166 & \text{高难度数学优化} \\ \text{IndustryOR} & 100 & \text{工业运筹问题} \\ \text{ComplexOR} & 18 & \text{复杂现实运筹问题} \end{array} 数据集NL4OptComplexLPNLP4LPOptiBenchOptMATHIndustryORComplexOR样本数23021124260516610018定位自然语言线性规划复杂线性规划子集自然语言到 LP/MILP综合优化建模高难度数学优化工业运筹问题复杂现实运筹问题

Table 2 数据集规模部分：七个优化基准。 评测集覆盖标准线性规划、复杂数学建模和工业运筹问题；双簇记忆使用另外 500 个不与这些基准重叠的问题构建。

2. Backbone 与 Baseline

基础模型横跨：

Qwen3-8B；
Qwen3-30B；
Qwen3-235B；
DeepSeek-V3.2；
GPT-5.1。

对比方法包括原始 Baseline、OptiMUS、AF-MCTS、OptiTree 和 DCM-Agent。

3. 严格端到端正确率

模型需要生成可执行代码，允许调用 Gurobi、PuLP、OR-Tools、SciPy 和 NetworkX。执行结果为：

o = P y t h o n ( c ) . o=Python(c). o=Python(c).

只有当需求中的数值答案与目标函数值都匹配 ground truth 时，才计为 solved。主指标是：

A c c u r a c y = # S o l v e d # T o t a l × 100 % . Accuracy=\frac{\#Solved}{\#Total}\times100\%. Accuracy=#Total#Solved×100%.

这种评估比只判断公式文本相似更严格，但论文没有详细说明浮点容差、无穷多等价解和代码超时的全部判定细节。

十一、主实验：不同模型规模上的完整结果

Table 2 很宽，下面按模型拆分复现，所有数值均为 solving accuracy（%）。

1. Qwen3-8B 与 Qwen3-30B

Qwen3-8B NL4Opt ComplexLP NLP4LP OptiBench OptMATH IndOR ComplexOR Avg. Baseline 41.74 16.11 35.12 30.58 10.24 19.00 22.22 27.99 OptiMUS 53.48 23.22 43.39 44.13 15.06 23.00 33.33 38.04 AF-MCTS 47.39 19.43 39.26 36.53 12.65 21.00 33.33 32.70 OptiTree 55.22 25.59 46.28 45.12 16.26 25.00 38.89 39.76 DCM-Agent 64.35 32.23 62.40 55.37 21.69 30.00 50.00 49.43 \begin{array}{l|rrrrrrrr} \textbf{Qwen3-8B} & \textbf{NL4Opt} & \textbf{ComplexLP} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} & \textbf{IndOR} & \textbf{ComplexOR} & \textbf{Avg.} \\ \hline \text{Baseline} & 41.74 & 16.11 & 35.12 & 30.58 & 10.24 & 19.00 & 22.22 & 27.99 \\ \text{OptiMUS} & 53.48 & 23.22 & 43.39 & 44.13 & 15.06 & 23.00 & 33.33 & 38.04 \\ \text{AF-MCTS} & 47.39 & 19.43 & 39.26 & 36.53 & 12.65 & 21.00 & 33.33 & 32.70 \\ \text{OptiTree} & 55.22 & 25.59 & 46.28 & 45.12 & 16.26 & 25.00 & 38.89 & 39.76 \\ \textbf{DCM-Agent} & \mathbf{64.35} & \mathbf{32.23} & \mathbf{62.40} & \mathbf{55.37} & \mathbf{21.69} & \mathbf{30.00} & \mathbf{50.00} & \mathbf{49.43} \end{array} Qwen3-8BBaselineOptiMUSAF-MCTSOptiTreeDCM-AgentNL4Opt41.7453.4847.3955.2264.35ComplexLP16.1123.2219.4325.5932.23NLP4LP35.1243.3939.2646.2862.40OptiBench30.5844.1336.5345.1255.37OptMATH10.2415.0612.6516.2621.69IndOR19.0023.0021.0025.0030.00ComplexOR22.2233.3333.3338.8950.00Avg.27.9938.0432.7039.7649.43

Table 2：Qwen3-8B 上的主实验。 DCM-Agent 在七个数据集和平均正确率上均为最高，平均达到 49.43%。

Qwen3-30B NL4Opt ComplexLP NLP4LP OptiBench OptMATH IndOR ComplexOR Avg. Baseline 55.22 28.44 52.07 43.64 16.87 25.00 38.89 40.52 OptiMUS 63.48 33.64 63.64 56.20 24.70 29.00 50.00 50.25 AF-MCTS 65.65 34.60 68.18 57.68 25.90 31.00 50.00 52.22 OptiTree 70.88 36.49 70.25 59.50 27.71 30.00 55.56 54.45 DCM-Agent 77.39 41.23 76.03 64.30 32.53 34.00 61.11 59.61 \begin{array}{l|rrrrrrrr} \textbf{Qwen3-30B} & \textbf{NL4Opt} & \textbf{ComplexLP} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} & \textbf{IndOR} & \textbf{ComplexOR} & \textbf{Avg.} \\ \hline \text{Baseline} & 55.22 & 28.44 & 52.07 & 43.64 & 16.87 & 25.00 & 38.89 & 40.52 \\ \text{OptiMUS} & 63.48 & 33.64 & 63.64 & 56.20 & 24.70 & 29.00 & 50.00 & 50.25 \\ \text{AF-MCTS} & 65.65 & 34.60 & 68.18 & 57.68 & 25.90 & 31.00 & 50.00 & 52.22 \\ \text{OptiTree} & 70.88 & 36.49 & 70.25 & 59.50 & 27.71 & 30.00 & 55.56 & 54.45 \\ \textbf{DCM-Agent} & \mathbf{77.39} & \mathbf{41.23} & \mathbf{76.03} & \mathbf{64.30} & \mathbf{32.53} & \mathbf{34.00} & \mathbf{61.11} & \mathbf{59.61} \end{array} Qwen3-30BBaselineOptiMUSAF-MCTSOptiTreeDCM-AgentNL4Opt55.2263.4865.6570.8877.39ComplexLP28.4433.6434.6036.4941.23NLP4LP52.0763.6468.1870.2576.03OptiBench43.6456.2057.6859.5064.30OptMATH16.8724.7025.9027.7132.53IndOR25.0029.0031.0030.0034.00ComplexOR38.8950.0050.0055.5661.11Avg.40.5250.2552.2254.4559.61

Table 2（续）：Qwen3-30B 上的主实验。 DCM-Agent 平均正确率为 59.61%，比最强基线 OptiTree 高 5.16 个百分点。

Qwen3-8B 的增益最醒目：

49.43 − 27.99 = 21.44 49.43-27.99=21.44 49.43−27.99=21.44

个百分点；相比最强基线 OptiTree 也高 9.67 个百分点。这说明结构化外部记忆能明显补偿小模型的范式判断能力。

2. Qwen3-235B

Qwen3-235B NL4Opt ComplexLP NLP4LP OptiBench OptMATH IndOR ComplexOR Avg. Baseline 78.13 40.76 74.38 60.83 31.33 32.00 55.56 57.74 OptiMUS 83.48 44.55 77.27 64.30 37.95 34.00 66.67 61.77 AF-MCTS 87.39 46.92 78.93 68.26 40.36 37.00 61.11 64.82 OptiTree 89.56 48.82 80.16 70.74 41.57 36.00 66.67 66.66 DCM-Agent 93.48 54.76 84.71 75.21 46.39 40.00 72.22 71.28 \begin{array}{l|rrrrrrrr} \textbf{Qwen3-235B} & \textbf{NL4Opt} & \textbf{ComplexLP} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} & \textbf{IndOR} & \textbf{ComplexOR} & \textbf{Avg.} \\ \hline \text{Baseline} & 78.13 & 40.76 & 74.38 & 60.83 & 31.33 & 32.00 & 55.56 & 57.74 \\ \text{OptiMUS} & 83.48 & 44.55 & 77.27 & 64.30 & 37.95 & 34.00 & 66.67 & 61.77 \\ \text{AF-MCTS} & 87.39 & 46.92 & 78.93 & 68.26 & 40.36 & 37.00 & 61.11 & 64.82 \\ \text{OptiTree} & 89.56 & 48.82 & 80.16 & 70.74 & 41.57 & 36.00 & 66.67 & 66.66 \\ \textbf{DCM-Agent} & \mathbf{93.48} & \mathbf{54.76} & \mathbf{84.71} & \mathbf{75.21} & \mathbf{46.39} & \mathbf{40.00} & \mathbf{72.22} & \mathbf{71.28} \end{array} Qwen3-235BBaselineOptiMUSAF-MCTSOptiTreeDCM-AgentNL4Opt78.1383.4887.3989.5693.48ComplexLP40.7644.5546.9248.8254.76NLP4LP74.3877.2778.9380.1684.71OptiBench60.8364.3068.2670.7475.21OptMATH31.3337.9540.3641.5746.39IndOR32.0034.0037.0036.0040.00ComplexOR55.5666.6761.1166.6772.22Avg.57.7461.7764.8266.6671.28

Table 2（续）：Qwen3-235B 上的主实验。 DCM-Agent 平均正确率达到 71.28%，比原始模型高 13.54 个百分点，比 OptiTree 高 4.62 个百分点。

在强模型上，外部记忆依然有效，但相对增益缩小。这符合直觉：模型自身已经掌握更多优化范式，记忆主要帮助它减少路径选择错误和检查遗漏。

3. DeepSeek-V3.2 与 GPT-5.1

DeepSeek-V3.2 NL4Opt ComplexLP NLP4LP OptiBench OptMATH IndOR ComplexOR Avg. Baseline 82.61 38.39 71.73 58.68 36.75 34.00 61.11 57.61 OptiMUS 86.09 43.60 75.21 62.15 39.76 36.00 66.67 61.20 AF-MCTS 89.13 46.92 78.10 67.27 43.98 39.00 66.67 65.14 OptiTree 90.87 47.87 79.34 70.08 47.59 38.00 72.22 67.18 DCM-Agent 95.22 53.55 83.06 74.05 52.73 41.00 77.77 71.47 \begin{array}{l|rrrrrrrr} \textbf{DeepSeek-V3.2} & \textbf{NL4Opt} & \textbf{ComplexLP} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} & \textbf{IndOR} & \textbf{ComplexOR} & \textbf{Avg.} \\ \hline \text{Baseline} & 82.61 & 38.39 & 71.73 & 58.68 & 36.75 & 34.00 & 61.11 & 57.61 \\ \text{OptiMUS} & 86.09 & 43.60 & 75.21 & 62.15 & 39.76 & 36.00 & 66.67 & 61.20 \\ \text{AF-MCTS} & 89.13 & 46.92 & 78.10 & 67.27 & 43.98 & 39.00 & 66.67 & 65.14 \\ \text{OptiTree} & 90.87 & 47.87 & 79.34 & 70.08 & 47.59 & 38.00 & 72.22 & 67.18 \\ \textbf{DCM-Agent} & \mathbf{95.22} & \mathbf{53.55} & \mathbf{83.06} & \mathbf{74.05} & \mathbf{52.73} & \mathbf{41.00} & \mathbf{77.77} & \mathbf{71.47} \end{array} DeepSeek-V3.2BaselineOptiMUSAF-MCTSOptiTreeDCM-AgentNL4Opt82.6186.0989.1390.8795.22ComplexLP38.3943.6046.9247.8753.55NLP4LP71.7375.2178.1079.3483.06OptiBench58.6862.1567.2770.0874.05OptMATH36.7539.7643.9847.5952.73IndOR34.0036.0039.0038.0041.00ComplexOR61.1166.6766.6772.2277.77Avg.57.6161.2065.1467.1871.47

Table 2（续）：DeepSeek-V3.2 上的主实验。 DCM-Agent 平均达到 71.47%，在所有数据集上均优于其他方法。

GPT-5.1 NL4Opt ComplexLP NLP4LP OptiBench OptMATH IndOR ComplexOR Avg. Baseline 87.39 55.45 84.30 68.26 43.38 44.00 66.67 67.62 OptiMUS 90.43 58.77 86.78 71.07 45.78 46.00 72.22 70.42 AF-MCTS 94.47 60.66 88.84 74.71 51.20 51.00 77.77 73.93 OptiTree 95.65 62.56 90.08 76.86 53.61 49.00 77.77 75.51 DCM-Agent 97.83 65.40 93.39 80.16 55.42 53.00 83.33 78.50 \begin{array}{l|rrrrrrrr} \textbf{GPT-5.1} & \textbf{NL4Opt} & \textbf{ComplexLP} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} & \textbf{IndOR} & \textbf{ComplexOR} & \textbf{Avg.} \\ \hline \text{Baseline} & 87.39 & 55.45 & 84.30 & 68.26 & 43.38 & 44.00 & 66.67 & 67.62 \\ \text{OptiMUS} & 90.43 & 58.77 & 86.78 & 71.07 & 45.78 & 46.00 & 72.22 & 70.42 \\ \text{AF-MCTS} & 94.47 & 60.66 & 88.84 & 74.71 & 51.20 & 51.00 & 77.77 & 73.93 \\ \text{OptiTree} & 95.65 & 62.56 & 90.08 & 76.86 & 53.61 & 49.00 & 77.77 & 75.51 \\ \textbf{DCM-Agent} & \mathbf{97.83} & \mathbf{65.40} & \mathbf{93.39} & \mathbf{80.16} & \mathbf{55.42} & \mathbf{53.00} & \mathbf{83.33} & \mathbf{78.50} \end{array} GPT-5.1BaselineOptiMUSAF-MCTSOptiTreeDCM-AgentNL4Opt87.3990.4394.4795.6597.83ComplexLP55.4558.7760.6662.5665.40NLP4LP84.3086.7888.8490.0893.39OptiBench68.2671.0774.7176.8680.16OptMATH43.3845.7851.2053.6155.42IndOR44.0046.0051.0049.0053.00ComplexOR66.6772.2277.7777.7783.33Avg.67.6270.4273.9375.5178.50

Table 2（续）：GPT-5.1 上的主实验。 DCM-Agent 平均正确率为 78.50%，比原始 GPT-5.1 高 10.88 个百分点，比 OptiTree 高 2.99 个百分点。

4. 主结果应该怎样理解

DCM-Agent 在 5 个模型 × 7 个数据集的全部组合上都是最佳，说明收益不是由单个数据集或模型驱动。

但 ComplexOR 只有 18 个样本，一个样本就对应 5.56 个百分点，因此该列的变化高度离散。论文也没有报告多次运行方差或显著性检验。对 50.00%、61.11%、72.22% 这类结果，应理解为 9/18、11/18、13/18，而不是非常精细的稳定差异。

十二、效率：结构化路径比树搜索快多少

方法 NLP4LP OptiBench OptMATH Baseline 8.3 s 13.7 s 21.7 s OptiMUS 26.5 s 46.6 s 86.3 s AF-MCTS 85.3 s 110.8 s 205.7 s OptiTree 17.7 s 33.5 s 61.6 s DCM-Agent 22.1 s 41.3 s 73.4 s \begin{array}{l|rrr} \textbf{方法} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} \\ \hline \text{Baseline} & 8.3s & 13.7s & 21.7s \\ \text{OptiMUS} & 26.5s & 46.6s & 86.3s \\ \text{AF-MCTS} & 85.3s & 110.8s & 205.7s \\ \text{OptiTree} & \mathbf{17.7s} & \mathbf{33.5s} & \mathbf{61.6s} \\ \text{DCM-Agent} & 22.1s & 41.3s & 73.4s \end{array} 方法BaselineOptiMUSAF-MCTSOptiTreeDCM-AgentNLP4LP8.3s26.5s85.3s17.7s22.1sOptiBench13.7s46.6s110.8s33.5s41.3sOptMATH21.7s86.3s205.7s61.6s73.4s

Table 3：Qwen3-235B 在三个数据集上的平均求解时间。 DCM-Agent 明显快于 AF-MCTS 和 OptiMUS，但慢于原始 Baseline 与 OptiTree。

以 OptMATH 为例，DCM-Agent 相比 AF-MCTS 的耗时下降：

205.7 − 73.4 205.7 ≈ 64.3 % . \frac{205.7-73.4}{205.7}\approx64.3\%. 205.7205.7−73.4≈64.3%.

这说明簇图把开放式树搜索压缩成少量候选路径后，能够减少无目的分支。

但论文所谓"balanced efficiency"更准确，不应写成"最快"。DCM-Agent 比 OptiTree 慢约 19.2%，比原始 Baseline 慢很多；它的卖点是用中等额外时间换来最高正确率。

另外，Table 3 只报告在线求解时间，没有把一次性的 500 条经验分类、LLM 聚类验证、知识合成和建图成本算进去。

十三、Memory Budget：更多节点是否持续有效

Memory Ratio 0 % 10 % 40 % 70 % 100 % NLP4LP 74.38 78.51 81.40 82.64 84.71 OptiBench 60.83 66.45 71.57 74.05 75.21 OptMATH 31.33 36.75 40.36 44.58 46.39 \begin{array}{c|rrrrr} \textbf{Memory Ratio} & 0\% & 10\% & 40\% & 70\% & 100\% \\ \hline \text{NLP4LP} & 74.38 & 78.51 & 81.40 & 82.64 & 84.71 \\ \text{OptiBench} & 60.83 & 66.45 & 71.57 & 74.05 & 75.21 \\ \text{OptMATH} & 31.33 & 36.75 & 40.36 & 44.58 & 46.39 \end{array} Memory RatioNLP4LPOptiBenchOptMATH0%74.3860.8331.3310%78.5166.4536.7540%81.4071.5740.3670%82.6474.0544.58100%84.7175.2146.39

Table 4：Qwen3-235B 在不同记忆预算下的正确率。 从无记忆到使用全部节点，三个数据集均单调提升；10% 记忆已经带来明显收益，之后仍有持续但逐渐减小的增益。

OptiBench 从 0% 到 10% 提升 5.62 个百分点，从 70% 到 100% 只提升 1.16 个百分点。这说明覆盖面重要，但边际收益会下降。

需要注意，Table 4 调整的是节点数量，不是 token budget 或簇数量。更多节点也可能改变聚类结构和知识合成质量，因此不能把结果简单解释为"上下文越长越好"；实际推理仍只检索有限的 K K K 条路径。

十四、Knowledge Inheritance：大模型记忆能否教小模型

1. Qwen3-8B 使用不同模型构建的记忆

Memory Constructor NLP4LP OptiBench OptMATH No Memory 35.12 30.58 10.24 Qwen3-8B 62.40 55.37 21.69 Qwen3-30B 67.36 59.34 23.49 Qwen3-235B 69.42 60.17 25.30 DeepSeek-V3.2 66.53 58.68 24.10 GPT-5.1 65.28 57.52 22.89 \begin{array}{l|rrr} \textbf{Memory Constructor} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} \\ \hline \text{No Memory} & 35.12 & 30.58 & 10.24 \\ \text{Qwen3-8B} & 62.40 & 55.37 & 21.69 \\ \text{Qwen3-30B} & 67.36 & 59.34 & 23.49 \\ \textbf{Qwen3-235B} & \mathbf{69.42} & \mathbf{60.17} & \mathbf{25.30} \\ \text{DeepSeek-V3.2} & 66.53 & 58.68 & 24.10 \\ \text{GPT-5.1} & 65.28 & 57.52 & 22.89 \end{array} Memory ConstructorNo MemoryQwen3-8BQwen3-30BQwen3-235BDeepSeek-V3.2GPT-5.1NLP4LP35.1262.4067.3669.4266.5365.28OptiBench30.5855.3759.3460.1758.6857.52OptMATH10.2421.6923.4925.3024.1022.89

Table 5：Qwen3-8B 的跨模型记忆迁移。 使用更强模型构建的记忆通常优于自建记忆，但最佳构建者是 Qwen3-235B，而不是最强的 GPT-5.1。

这就是论文所说的 "knowledge inheritance"：记忆构建与推理解耦后，小模型可以继承大模型抽取出的结构先验。

但结果不是单调的。对 Qwen3-8B 而言，Qwen3-235B Memory 最好，DeepSeek-V3.2 与 GPT-5.1 反而下降。作者推测，更强模型生成了更密集、更细的簇知识，超过了小模型的处理能力。

我的理解是，还可能存在模型家族对齐因素：同属 Qwen 系列的表达方式、代码风格和指令偏好更容易被 Qwen3-8B 消化。论文没有通过控制知识长度、簇数量或同家族因素验证这一点，因此"处理容量过载"仍是合理假设，不是已证明机制。

2. Qwen3-235B 使用不同模型构建的记忆

Memory Constructor NLP4LP OptiBench OptMATH No Memory 74.38 60.83 31.33 Qwen3-8B 78.51 69.59 40.96 Qwen3-30B 82.64 73.22 43.98 Qwen3-235B 84.71 75.21 46.39 DeepSeek-V3.2 85.54 76.03 47.59 GPT-5.1 86.36 77.36 48.19 \begin{array}{l|rrr} \textbf{Memory Constructor} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} \\ \hline \text{No Memory} & 74.38 & 60.83 & 31.33 \\ \text{Qwen3-8B} & 78.51 & 69.59 & 40.96 \\ \text{Qwen3-30B} & 82.64 & 73.22 & 43.98 \\ \text{Qwen3-235B} & 84.71 & 75.21 & 46.39 \\ \text{DeepSeek-V3.2} & 85.54 & 76.03 & 47.59 \\ \textbf{GPT-5.1} & \mathbf{86.36} & \mathbf{77.36} & \mathbf{48.19} \end{array} Memory ConstructorNo MemoryQwen3-8BQwen3-30BQwen3-235BDeepSeek-V3.2GPT-5.1NLP4LP74.3878.5182.6484.7185.5486.36OptiBench60.8369.5973.2275.2176.0377.36OptMATH31.3340.9643.9846.3947.5948.19

Table 5（续）：Qwen3-235B 的跨模型记忆迁移。 目标模型容量足够时，记忆构建模型越强，性能基本越高；GPT-5.1 Memory 在三个数据集上最佳。

两部分合在一起说明：高质量记忆可以跨模型转移，但"最强教师 → 最弱学生"并非总是最佳。记忆也需要与接收模型的理解带宽匹配。

十五、簇数量分析：强模型为什么能分得更细

Figure 4 报告了不同模型构建出的簇数量：

构建模型 Modeling Clusters Coding Clusters Qwen3-8B 11 6 Qwen3-30B 18 9 Qwen3-235B 37 11 DeepSeek-V3.2 54 18 GPT-5.1 78 24 \begin{array}{l|rr} \textbf{构建模型} & \textbf{Modeling Clusters} & \textbf{Coding Clusters} \\ \hline \text{Qwen3-8B} & 11 & 6 \\ \text{Qwen3-30B} & 18 & 9 \\ \text{Qwen3-235B} & 37 & 11 \\ \text{DeepSeek-V3.2} & 54 & 18 \\ \text{GPT-5.1} & 78 & 24 \end{array} 构建模型Qwen3-8BQwen3-30BQwen3-235BDeepSeek-V3.2GPT-5.1Modeling Clusters1118375478Coding Clusters69111824

Figure 4 数据复现：不同 LLM 构建的 Modeling 与 Coding Cluster 数量。 模型能力越强，得到的两类簇越多；Modeling Cluster 的增幅尤其明显。

作者认为，这说明强模型能区分更细微的数学结构，避免把不同范式错误合并。

但簇更多不必然更好。过细会导致：

每个簇样本过少，知识合成不稳定；
二部图变稀疏，边权缺乏统计支持；
小模型难以处理高密度的候选知识；
相近簇之间的边界可能只是模型风格差异。

Table 5 中 GPT-5.1 Memory 对 Qwen3-8B 的退化，正好提示了这种边界。

十六、双簇消融：建模簇与代码簇谁更重要

Figure 5：Qwen3-235B 上的双簇消融。 完整 DCM-Agent 在 NLP4LP、OptiBench、OptMATH 分别为 84.7%、75.2%、46.4%；移除 Modeling Cluster 后下降至 77.7%、68.1%、39.8%，移除 Coding Cluster 后为 81.0%、72.1%、42.8%。

复现为表格：

设置 NLP4LP OptiBench OptMATH 完整 DCM-Agent 84.7 75.2 46.4 w/o Modeling Cluster 77.7 68.1 39.8 w/o Coding Cluster 81.0 72.1 42.8 \begin{array}{l|rrr} \textbf{设置} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} \\ \hline \textbf{完整 DCM-Agent} & \mathbf{84.7} & \mathbf{75.2} & \mathbf{46.4} \\ \text{w/o Modeling Cluster} & 77.7 & 68.1 & 39.8 \\ \text{w/o Coding Cluster} & 81.0 & 72.1 & 42.8 \end{array} 设置完整 DCM-Agentw/o Modeling Clusterw/o Coding ClusterNLP4LP84.777.781.0OptiBench75.268.172.1OptMATH46.439.842.8

Figure 5 数据复现：Modeling Cluster 与 Coding Cluster 消融。 两种簇都有贡献，但去掉 Modeling Cluster 的下降更大。

三个数据集上，移除 Modeling Cluster 都下降约 6.6--7.1 个百分点；移除 Coding Cluster 下降约 3.1--3.6 个百分点。这验证了论文的问题判断：复杂优化任务首先难在选择和验证数学结构，其次才是把结构翻译成求解器代码。

不过，消融只有 "去掉一侧簇"，没有进一步拆分：

instance retrieval 与 cluster retrieval；
二部图与无图的独立组合；
Approach、Checklist、Pitfall；
repair 与 backtracking。

因此，实验能证明双簇总体有效，却不能精确分配每个内部机制的增益。

十七、参数敏感性：K、N、M 分别控制什么

设置 NLP4LP OptiBench OptMATH K = 1 79.34 70.91 40.36 K = 3 84.71 75.21 46.39 K = 5 83.06 74.05 43.98 N = 1 84.30 74.21 44.58 N = 5 84.71 75.21 46.39 N = 10 82.64 72.73 42.77 M = 1 82.23 72.56 42.17 M = 3 84.71 75.21 46.39 M = 5 85.54 75.87 46.99 \begin{array}{c|rrr} \textbf{设置} & \textbf{NLP4LP} & \textbf{OptiBench} & \textbf{OptMATH} \\ \hline K=1 & 79.34 & 70.91 & 40.36 \\ K=3 & \mathbf{84.71} & \mathbf{75.21} & \mathbf{46.39} \\ K=5 & 83.06 & 74.05 & 43.98 \\ \hline N=1 & 84.30 & 74.21 & 44.58 \\ N=5 & \mathbf{84.71} & \mathbf{75.21} & \mathbf{46.39} \\ N=10 & 82.64 & 72.73 & 42.77 \\ \hline M=1 & 82.23 & 72.56 & 42.17 \\ M=3 & 84.71 & 75.21 & 46.39 \\ M=5 & \mathbf{85.54} & \mathbf{75.87} & \mathbf{46.99} \end{array} 设置K=1K=3K=5N=1N=5N=10M=1M=3M=5NLP4LP79.3484.7183.0684.3084.7182.6482.2384.7185.54OptiBench70.9175.2174.0574.2175.2172.7372.5675.2175.87OptMATH40.3646.3943.9844.5846.3942.7742.1746.3946.99

Table 6：检索数 K K K、记忆更新阈值 N N N 与候选路径数 M M M 的敏感性。 K = 3 K=3 K=3、 N = 5 N=5 N=5 最优； M M M 增大仍有小幅收益，但论文为效率选择 M = 3 M=3 M=3。

1. K K K：信息不足与检索噪声之间的平衡

K = 1 K=1 K=1 无法覆盖足够范式， K = 5 K=5 K=5 又引入过多候选。与 CFGM 的 Top-k 实验相似，这再次说明 Agent Memory 不是"召回越多越好"。

2. N N N：过拟合单例与延迟合成之间的平衡

N = 1 N=1 N=1 时，每个新样本都可能改变簇知识； N = 10 N=10 N=10 时，新增经验很久才会进入概括。 N = 5 N=5 N=5 在稳定性和更新速度之间取得最好结果。

3. M M M：更多备选路径带来收益，但成本增加

M M M 从 3 增至 5 后仍有提升，但幅度只有 0.66--0.83 个百分点。因为每条路径都要执行建模、代码、验证和可能的修复，作者选择 M = 3 M=3 M=3 作为性价比配置。

十八、失败模式与反例

1. 最强记忆不一定适合最小模型

Table 5 是论文自己提供的反例。GPT-5.1 Memory 没有让 Qwen3-8B 达到最好结果。结构知识也存在"接收带宽"，过细的簇和高密度 Checklist 可能让小模型失焦。

2. 更多检索并不总是更好

K = 5 K=5 K=5 低于 K = 3 K=3 K=3，说明候选范式过多会重新引入论文试图解决的 cognitive interference。双簇只能组织冲突，不能保证召回结果没有冲突。

3. 共现边可能继承数据偏差

二部图以历史共现次数作为边权。如果建库问题偏向 Gurobi 或某类 MIP，图会把这种数据分布当成可靠先验。对罕见但更合适的 solver 路径，边权机制可能形成压制。

4. 可执行仍不等于语义正确

Figure 6 的连续 LP 代码成功执行但语义错误。DCM-Agent 加入 Checklist 可以减少此类问题，却仍由 LLM 执行建模验证。若 Checklist 没覆盖隐含约束，求解器依然会对错误模型给出"最优解"。

5. 所有候选路径都不在图中时会失败

DCM-Agent 擅长在已有 Modeling/Coding Clusters 中导航。当新问题要求从未出现的算法范式、混合求解器或非标准约束时，instance retrieval、cluster retrieval 与强边 prior 可能全部失效。

6. 错误主要集中在代码修复还是模型回退，论文没有拆开报告

论文给出了整体准确率，却没有统计：

首条路径成功率；
Checklist 拦截了多少错误；
repair 成功率；
backtracking 触发次数与收益；
Modeling error 与 Coding error 的比例。

因此，Generate--Verify--Repair--Backtrack 的流程合理，但各阶段的实际贡献仍缺少细粒度证据。

十九、与 Agent Memory 系列方法的横向比较

方法记忆对象关键结构核心问题 A-MEM 通用记忆条目动态链接与组织扁平记忆缺少关联 MAGMA 多视角记忆关系多图结构单一相似度遗漏多种关系 CoM 长期交互历史连续压缩记忆历史增长与信息保持 ReMemR1 写入中的历史记忆 Callback 回看边读边记的信息损失 Mem 2 Evolve 记忆与策略经验持续演化静态记忆难以长期适应 CFGM 规划轨迹与异常粗到细知识落地采集、蒸馏、纠错割裂 DCM-Agent 优化建模与代码经验双簇 + 二部图多范式经验互相干扰 \begin{array}{l|l|l|l} \textbf{方法} & \textbf{记忆对象} & \textbf{关键结构} & \textbf{核心问题} \\ \hline \text{A-MEM} & \text{通用记忆条目} & \text{动态链接与组织} & \text{扁平记忆缺少关联} \\ \text{MAGMA} & \text{多视角记忆关系} & \text{多图结构} & \text{单一相似度遗漏多种关系} \\ \text{CoM} & \text{长期交互历史} & \text{连续压缩记忆} & \text{历史增长与信息保持} \\ \text{ReMemR1} & \text{写入中的历史记忆} & \text{Callback 回看} & \text{边读边记的信息损失} \\ \text{Mem}^{2}\text{Evolve} & \text{记忆与策略经验} & \text{持续演化} & \text{静态记忆难以长期适应} \\ \text{CFGM} & \text{规划轨迹与异常} & \text{粗到细知识落地} & \text{采集、蒸馏、纠错割裂} \\ \textbf{DCM-Agent} & \text{优化建模与代码经验} & \text{双簇 + 二部图} & \text{多范式经验互相干扰} \end{array} 方法A-MEMMAGMACoMReMemR1Mem2EvolveCFGMDCM-Agent记忆对象通用记忆条目多视角记忆关系长期交互历史写入中的历史记忆记忆与策略经验规划轨迹与异常优化建模与代码经验关键结构动态链接与组织多图结构连续压缩记忆Callback 回看持续演化粗到细知识落地双簇 + 二部图核心问题扁平记忆缺少关联单一相似度遗漏多种关系历史增长与信息保持边读边记的信息损失静态记忆难以长期适应采集、蒸馏、纠错割裂多范式经验互相干扰

横向比较：DCM-Agent 与代表性 Agent Memory 方法。 DCM-Agent 关注的不是对话记忆容量，而是领域任务中多个有效范式之间的结构歧义。

1. 与 A-MEM 的关系

A-MEM 强调记忆条目自主建立关联；DCM-Agent 则预先规定了一种领域结构：建模簇与代码簇必须分开，并只能通过二部边连接。

A-MEM 更通用，DCM-Agent 的归纳偏置更强。优化任务恰好天然存在 formulation/code 两层，因此强结构能换来更精确的导航。

2. 与 MAGMA 的关系

MAGMA 用多图表达同一记忆的多类关系，DCM-Agent 也承认单一向量空间不够。但 DCM-Agent 不是多个并列关系图，而是两个异质节点集合构成的二部图。

如果扩展 DCM-Agent，可以再加入数据预处理簇、求解器簇、验证簇，形成多部图；这会更接近 MAGMA 的多视角思想，同时也增加路径搜索复杂度。

3. 与 CFGM 的关系

两者都把历史轨迹转成结构化知识，也都区分正向经验与错误信息：

CFGM：Experience Tips + Key Information Reflection；
DCM-Agent：Approach + Checklist + Pitfall。

差别在于，CFGM 的核心轴是从粗到细的生命周期；DCM-Agent 的核心轴是建模与编码两个相互独立又需要配对的空间。

4. 与 ReMemR1 / Mem²Evolve 的关系

DCM-Agent 在簇累计 N N N 个新节点时能够增量更新知识，看起来具有一定演化特征。但论文实验主要从离线历史档案建库，在线解题的新轨迹没有完整回流到分类、聚类、边权更新和知识修订流程。

因此，它当前更像"可增量构建的数据结构"，还不是持续在线演化的 Memory Agent。ReMemR1 的回看机制和 Mem²Evolve 的更新思想可以补上这一闭环。

二十、对 Coding Agent、Tool Agent 与 Multi-Agent 的启发

1. Coding Agent：把设计决策和实现模式分开记

代码 Agent 经常把两种知识混在一起：

架构层：应该采用事件驱动、事务、缓存、批处理还是消息队列；
实现层：当前仓库用什么框架、API、测试工具和编码约定。

可以仿照 DCM-Agent 构建 Architecture Cluster 与 Implementation Cluster，再记录可靠配对。例如：

Outbox Pattern ↔ PostgreSQL Transaction + Kafka Producer . \text{Outbox Pattern} \leftrightarrow \text{PostgreSQL Transaction + Kafka Producer}. Outbox Pattern↔PostgreSQL Transaction + Kafka Producer.

当实现失败时，先在当前实现簇内修复；若架构假设不成立，再回退到其他候选架构，而不是反复修改同一段代码。

2. Tool Agent：将"意图规划"和"工具调用"解耦

Tool Agent 可以建立：

Planning Cluster：任务分解、权限判断、数据依赖；
Tool Cluster：API、参数 schema、重试策略和副作用；
二部边：哪些计划曾由哪些工具链可靠完成。

Approach 用于生成调用计划，Checklist 用于调用前验证，Pitfall 用于处理错误码、速率限制和不完整返回。

3. Multi-Agent：不同角色给出的是不同范式，而非简单投票

多个 Agent 对同一任务产生不同方案时，不应把所有回答拼在一起让主 Agent 投票。可以把方案聚类为不同 Modeling Paths，再将每条路径与合适的执行 Agent、工具和验证 Agent 配对。

这会把"多 Agent 讨论"从文本堆叠变成结构化路径选择。

4. 结构化负经验比失败日志更有价值

Type B 和 Type C 的设计尤其值得工程借鉴。失败日志应被转成：

Pitfall = { t r i g g e r , w r o n g a s s u m p t i o n , e r r o r s i g n a t u r e , r e c o v e r y b o u n d a r y } . \text{Pitfall}= \{trigger,wrong\ assumption,error\ signature,recovery\ boundary\}. Pitfall={trigger,wrong assumption,error signature,recovery boundary}.

只有这样，失败才会在下一次相似任务中进入验证与修复阶段，而不是留在日志系统里无人使用。

二十一、局限性

1. 作者明确承认的局限：初始化成本

构建双簇记忆需要：

收集并多次求解历史问题；
分类 Type A/B/C；
拆分 Modeling 与 Coding；
生成 embedding；
用 LLM 验证簇归属；
按阈值合成簇知识；
更新二部图。

这是一笔不可忽略的一次性成本。作者将其视为可被长期使用摊薄的 sunk cost，并计划未来加入在线更新，避免完整重建。

2. 进一步的局限

2.1 缺少初始化成本的实测数字

Limitations 强调初始化慢，但 Table 3 只报告在线时间。没有总建库 token、LLM 调用次数、耗时、存储量和更新开销，就无法判断需要多少在线任务才能摊平成本。

2.2 二部图边权过于简单

共现次数没有考虑成功率、数据新鲜度、难度或置信度。更合理的边可以是：

w i j = f ( success rate , frequency , recency , difficulty , repair cost ) . w_{ij}=f( \text{success rate}, \text{frequency}, \text{recency}, \text{difficulty}, \text{repair cost}). wij=f(success rate,frequency,recency,difficulty,repair cost).

2.3 聚类和知识合成都依赖 LLM

LLM verifier 可能错误合并或过度拆分， L L M s y n t h LLM_{synth} LLMsynth 也可能删掉少见但关键的 Pitfall。论文没有报告聚类纯度、人工一致性或知识事实性评估。

2.4 500 条自建问题由共同作者标注

论文说明这些问题由具备运筹与应用数学背景的博士生、硕士生共同作者收集和验证。专业性有保障，但没有外部盲审、一致性系数或数据公开质量分析，仍可能存在作者偏差。

2.5 Baseline 公平性与复现细节仍需代码核对

不同方法的 LLM 调用预算、重试次数、Prompt 长度和搜索宽度会显著影响准确率与时间。论文给出整体流程，但没有在主文中列出所有等价预算控制。

2.6 只验证了优化领域的二层结构

Modeling/Coding 的拆分具有很强领域合理性，但不能直接证明双簇结构适用于所有 Agent Memory。其他任务可能需要三层或动态图，甚至不存在稳定的两阶段映射。

二十二、我的理解和启发

1. DCM-Agent 的本质是把"答案记忆"改成"路径记忆"

普通案例库保存：

x i → y i . x_i\rightarrow y_i. xi→yi.

DCM-Agent 保存的是：

x i → C i M → w i j C j C → E ( c ) . x_i \rightarrow C_i^M \xrightarrow{w_{ij}} C_j^C \rightarrow \mathcal{E}(c). xi→CiMwij CjC→E(c).

也就是说，它记住的不是一个结果，而是从问题结构、建模范式到代码实现的可行路径。

2. 多范式歧义不应该靠"融合"解决

很多 Agent 系统面对多个候选时，会让 LLM 把它们总结成一个答案。但 ILP、CP、DP 的冲突不能通过文字融合消失。真正有效的方法是：

保持路径分离；
为每条路径提供专属验证标准；
失败时允许切换路径。

这也是 DCM-Agent 比普通经验摘要更重要的思想。

3. Approach、Checklist、Pitfall 对应三种认知动作

这三个字段分别对应：

Generate → Verify → Repair . \text{Generate} \rightarrow \text{Verify} \rightarrow \text{Repair}. Generate→Verify→Repair.

它们不是为了让记忆看起来结构化，而是直接嵌入控制流。好的 Memory Schema 应该回答的不只是"存什么字段"，还包括"哪个字段在哪一步被谁使用"。

4. Knowledge Inheritance 提示了一个新的模型压缩方向

传统蒸馏把大模型知识写入小模型参数；DCM-Agent 则把大模型知识写进外部记忆：

L L M l a r g e → construct M e m o r y → retrieve L L M s m a l l . LLM_{large} \xrightarrow{\text{construct}} Memory \xrightarrow{\text{retrieve}} LLM_{small}. LLMlargeconstruct Memoryretrieve LLMsmall.

这种"记忆蒸馏"无需训练，知识可以编辑、替换和审计。但 Table 5 同样说明，外部知识必须压缩到小模型可消费的粒度。未来可以根据目标模型自动控制簇数量、单条 Checklist 长度和候选路径数。

5. 下一步应从共现图走向因果验证图

当前强边表示历史上经常配对，但工程上更希望知道：某 Coding Cluster 是否真的使某 Modeling Cluster 更容易成功。

可以为边保存：

尝试次数与成功次数；
首次成功率；
平均修复次数；
典型错误类型；
适用求解器版本；
反例和失效条件。

这样，图就从"经验共现关系"升级为"带证据的策略兼容图"。

6. 在线闭环是这项工作的自然下一步

完整的持续记忆链路应该是：

Retrieve Path → Solve → Classify New Trajectory → Update Clusters → Reweight Graph → Revise Knowledge . \text{Retrieve Path} \rightarrow \text{Solve} \rightarrow \text{Classify New Trajectory} \rightarrow \text{Update Clusters} \rightarrow \text{Reweight Graph} \rightarrow \text{Revise Knowledge}. Retrieve Path→Solve→Classify New Trajectory→Update Clusters→Reweight Graph→Revise Knowledge.

还要处理旧 Pitfall 过期、簇合并与拆分、错误经验污染以及版本回滚。做到这一点，DCM-Agent 才会从离线构建的领域记忆库，变成真正长期演化的优化 Agent。

二十三、总结

DCM-Agent 解决的是一种过去容易被普通 RAG 掩盖的问题：优化任务的历史经验不是同质案例集合，而是一组可能相互冲突的建模范式和代码实现路径。

它先将历史轨迹按 Always Correct、Recovered、Persistent Failure 分层，再从中提取 Approach、Checklist、Pitfall；随后把每条经验拆成 Modeling 与 Coding，分别聚类，并用加权二部图记录可靠配对。面对新题时，它同时检索相似实例和抽象建模簇，沿图生成候选路径，并执行 Generate--Verify--Repair--Backtrack。

实验覆盖 7 个基准与 5 种不同规模模型。DCM-Agent 在全部主结果中取得最高准确率，小模型平均提升尤其显著；它比重型树搜索更快，但并非最快方法。消融显示 Modeling Cluster 的贡献大于 Coding Cluster。跨模型实验则发现，大模型构建的记忆可以被小模型继承，但知识密度超过目标模型处理能力时也会退化。

论文的主要不足是初始化成本缺少完整量化、内部模块消融不够细、二部图只使用共现边权、LLM 聚类质量没有直接评估，以及在线新经验尚未形成持续更新闭环。

最后用一句话概括：

DCM-Agent 的核心贡献，是将优化经验从"相似题答案库"重构为"建模簇---代码簇"的可导航路径图，让 Agent 能在冲突范式之间保持分离、按证据配对，并在失败时修复或回退。

参考资料

Xinyu Zhang, Yuchen Wan, Boxuan Zhang, Zesheng Yang, Lingling Zhang, Bifan Wei, Jun Liu. Dual-Cluster Memory Agent: Resolving Multi-Paradigm Ambiguity in Optimization Problem Solving. ACL 2026.
AhmadiTeshnizi et al. OptiMUS: Scalable Optimization Modeling with (MI)LP Solvers and Large Language Models. ICML 2024.
Astorga et al. Autoformulation of Mathematical Optimization Models Using LLMs. ICML 2025.
Liu et al. OptiTree: Hierarchical Thoughts Generation with Tree Search for LLM Optimization Modeling. NeurIPS 2025.
Ramamonjison et al. NL4Opt Competition: Formulating Optimization Problems Based on Their Natural Language Descriptions. NeurIPS Competition Track 2023.