# How to Make a Coding Agent Smarter Without Touching the Model or the Prompt
**作者**: AlphaSignal AI
**日期**: 2026-04-30T17:14:18.000Z
**来源**: [https://x.com/AlphaSignalAI/status/2049900160080077229](https://x.com/AlphaSignalAI/status/2049900160080077229)
---
A new paper evolves a coding agent's tools, middleware, and memory automatically. It beats every human-tuned harness in 32 hours.
The system prompt alone regresses. Editing it as the only adaptation surface drops pass@1 by 2.3 points on Terminal-Bench 2.
AHE (Agentic Harness Engineering) is the framework that produced this finding. It holds the base model frozen, evolves all seven harness components automatically against rollouts, and lifts a bash-only seed from 69.7% to 77.0% in ten iterations.
The result beats human-designed Codex-CLI (71.9%), the prompt-only self-evolver ACE (68.9%), and the trajectory-feedback baseline TF-GRPO (72.3%) on the same 89-task panel in 32 hours.
The transfer ships the evolved workspace unchanged: 12% fewer tokens on SWE-bench-verified, +5.1 to +10.1pp across four other model families, with the largest gain on the weakest base.
> “If you didn’t quite catch that intro, you should definitely check out our Harness Engineering workshop. If you did follow along, you should still give it a look anyway!” more details at the end.
## Context
The paper is authored by Jiahang Lin, Shichun Liu, Chengjun Pan, and collaborators at Fudan University, Peking University, and Shanghai Qiji Zhifeng, titled "Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses" (arXiv 2604.25850, April 28, 2026, MIT-licensed code).
A coding agent's harness is everything around the model: system prompt, tool definitions, middleware, skills, sub-agents, memory. Production teams hand-tune these by inspecting trajectories and editing files. The manual loop is slow and the gains scatter across undocumented decisions.
Prior automated work optimizes one component at a time, almost always the prompt or an in-context playbook (ACE, GEPA, DSPy) or the trajectory distribution (TF-GRPO, GRPO variants). Tools, middleware, and memory stay closed.
AHE evolves the full harness as a combinatorial whole and treats every edit as a falsifiable contract verified against the next round's task outcomes.
## How AHE works
The central design move is that every phase of the loop produces structured, file-level artifacts another agent can read.
Component observability. The harness is instantiated on the NexAU framework, which exposes seven editable component types as files at fixed mount points: system prompt, tool description, tool implementation, middleware, skill, sub-agent configuration, and long-term memory. Each failure pattern maps cleanly to one component class. Each logical edit becomes one git commit, so file-level diffs and rollback come for free.
The seed harness is deliberately minimal, just a single bash tool with no middleware or skills, so every component the loop adds has to earn its place against measured rollouts.
Experience observability. The Agent Debugger framework distills raw rollout traces (millions of tokens) into a layered evidence corpus. Each trajectory message lives in its own file. Per-task root-cause reports identify failure patterns.
A benchmark-level overview aggregates every report into the evolve agent's entry point. Original traces stay accessible for verification but are never the first read.
Decision observability. Every edit ships with a change_manifest.json entry naming the failure pattern it addresses, the predicted task fixes, the at-risk regressions, and the constraint level (prompt, tool description, tool implementation, middleware, skill).
In the next round, the loop intersects predicted fixes and regressions against observed task-level deltas. Edits whose predictions don't materialize get rolled back automatically at file granularity. Self-justification becomes measurement.
## The outer loop
The plain pseudocode is included in appendix section at the end
The load-bearing choice is that attribution runs before distillation. The verdict for prior edits lands inside the evidence corpus the evolve agent reads, binding each manifest entry as a contract instead of a rationale.
The evolve agent writes only inside workspace/. The runs directory, tracer, verifier, and LLM config are read-only. The seed system prompt is non-deletable.
These restrictions block the shortcuts an unconstrained self-modifier would take, like disabling the verifier or raising the reasoning budget, and keep every recorded gain attributable to harness edits.
## Evidence
Ten AHE iterations on Terminal-Bench 2 (89 tasks, k=2 rollouts, GPT-5.4 high reasoning, ~32 hours total runtime) lift pass@1 from 69.7% to 77.0%. AHE outperforms three human-designed harnesses (opencode 47.2%, terminus-2 62.9%, Codex-CLI 71.9%) and both self-evolve baselines (ACE 68.9%, TF-GRPO 72.3%).
On Easy and Medium tiers AHE leads cleanly. On Hard it slips to 53.3% behind Codex-CLI's 56.7%, traced to component interference rather than missing capability.
Cross-benchmark transfer holds without re-evolution. On SWE-bench-verified (500 tasks across seven repos), AHE achieves the highest aggregate at 75.6% while spending 12% fewer tokens than the seed, 21% fewer than TF-GRPO, and 32% fewer than ACE.
Gains concentrate on django and sphinx-doc, the two largest, most token-expensive repos. Cost efficiency on SWE-bench (Succ/Mtok): AHE 1.64, NexAU₀ 1.43, TF-GRPO 1.27, ACE 1.10.
Cross-model transfer is the strongest evidence that the harness encodes general engineering experience. The same evolved workspace, evaluated unchanged on five alternate bases, produces five positive gains: +10.1pp on deepseek-v4-flash (51.7→61.8), +6.3pp on qwen-3.6-plus (56.2→62.5), +5.1pp on gemini-3.1-flash-lite-preview (36.5→41.6), and +2.3pp on both GPT-5.4 medium and xhigh.
Weaker bases benefit more because they lean on the coordination patterns AHE has fixed inside tools, middleware, and memory. Stronger bases re-derive the same coordination from the prompt cheaply.
The component ablation is the load-bearing finding. Swapping a single AHE component into the bash-only seed: memory alone +5.6pp, tools alone +3.3pp, middleware alone +2.2pp, system prompt alone −2.3pp. The harness components ACE and TF-GRPO never edit are exactly where the gain lives.
## Four case studies
The paper traces four trajectories from failure to fix across iterations 2, 5, 6, and 8. Each peak in the best-so-far curve lines up with one trajectory.
db-wal-recovery (iteration 2). The agent had to reconstruct a SQLite database from a corrupted write-ahead log. The failing rollout invented missing rows from a guessed pattern (value = id × 100) and self-checked on row count instead of the verifier's value assertions.
The fix was a 68-line append to the system prompt with eight numbered rules: contract first, mirror the evaluator, generalize without overfitting visible samples. None of the rules mentions SQLite, WAL, or this task. The rules were proposed for a different cluster of partial-pass tasks and carried over by accident, flipping db-wal-recovery 1/2 → 2/2 and holding 2/2 every iteration after.
path-tracing (iteration 5). The agent rendered a correct image, self-checked it, then issued rm -rf as a final tidy-up step and submitted on the cleanup's exit code. The verifier found nothing on disk and rejected the rollout. The seed prompt already had advice against destroying verified state, but no execution-time mechanism enforced it.
The iteration-5 fix installed a publish-state guard inside the shell tool: when the shell observes a successful evaluator-style check, it parses the acceptance command for protected paths and intercepts later deletes. Task flips 0/2 → 2/2.
mcmc-sampling-stan (iteration 6). The agent computed a fake posterior via grid integration, fired the real MCMC run as a background job, killed it before convergence "to preserve the deliverables," and submitted the fake. This failed for five straight iterations.
Iteration 6 closed it with two components working together: the publish-state guard extended to protect script entrypoints (analysis.R), and a new ExecutionRiskHintsMiddleware watching the live command history for seven cross-step risk patterns (proxy validators, shallow validation, localhost-only checks, repeated retries against the same error, among others). Task flips 0/2 → 2/2 and stays.
configure-git-webserver (iteration 8). The agent reached a working webserver, self-checked via localhost curl, then issued ALLOW_POST_SUCCESS_RESET-prefixed cleanup commands that wiped the live web root and reset the git ref "to leave a clean repo for grading." The external verifier got a 404.
Iteration 8 patched the override token: deletion of protected outputs and reset of protected roots became hard blocks the token can no longer wipe. A before_model hook promoted execution-risk warnings into FRAMEWORK reminders visible on the next model turn. Iteration 8's overall score reached 76.97, the run's high-water mark.
The pattern across all four cases: prompts say what to avoid, but execution-time enforcement is what changes outcomes. Three of the four winning fixes shipped at the tool-implementation or middleware level.
## Limitations
Hard-tier slip. AHE marginally trails Codex-CLI on Hard (53.3% vs 56.7%). Memory, middleware, and the system prompt all push toward the same closure-style verification, which spends turn budget on redundant re-checks. Swapping AHE's long-term memory alone into the seed (no other components) already surpasses Codex on Hard.
Non-additive component interaction. Three positive single-component gains sum to +11.1pp, but full AHE only achieves +7.3pp. Stacking the components costs 3.8pp. The evolve agent optimizes an aggregate dominated by 55 Medium tasks, so it converges to a Medium-heavy trade-off that returns part of the Hard memory effect.
Regression blindness. Across nine evaluation rounds, the evolve agent issued 43 unique regression predictions and only 5 landed (precision 11.6%). 40 unforeseen regressions actually occurred (recall 11.1%). Fix predictions are 5× above random. Regression predictions are barely 2× above.
The agent can justify why an edit should help. It cannot reliably name what the same edit will break.
Benchmark scope. The full evolution run is on Terminal-Bench 2. Cross-benchmark and cross-model transfer evidence is encouraging, but a non-Terminal-Bench-2 evolution run is what would close the benchmaxxing question. The authors flag this and call it out as a generalization hazard.
So the best recommendation is to treat AHE as a controlled research prototype that already produces a frozen harness worth studying, while waiting for evolution runs on a second benchmark before adopting the framework as a deployment-grade self-improvement loop.
## AlphaSignal Take
Worth Watching. The framework does what it claims, the receipts (change manifests + auto-rollback) replace self-justification with measurement, and the cross-model transfer is the strongest signal yet that harness structure encodes coordination patterns weaker bases cannot re-derive cheaply.
The two unfinished pieces are the regression-blindness gap and a second-benchmark evolution run. Closing either pushes it from research-prototype to production-grade.
The forward-looking entity to watch is NexAU, the substrate the loop runs on, since the framework's reach scales with how many production agents adopt the file-level component contract.
## Who benefits, who doesn't
Benefits: teams running long-horizon coding agents on multi-step terminal or repository workflows, anyone hand-tuning prompts beyond a rough first pass, ML engineers evaluating self-evolution loops as an alternative to fine-tuning, and researchers studying test-time adaptation surfaces that don't require gradient updates.
Skips: teams whose agent loop is short-horizon API-call chains, anyone without rollout traces or a verifier with binary pass/fail signal, and teams already invested in prompt-only frameworks (ACE, GEPA, DSPy) that cannot open the harness components where the gain lives.
## Practitioner implication
ML engineers can now evolve a coding agent's tools, middleware, and memory automatically against a benchmark, now that observability primitives turn each component edit into a falsifiable contract.
## The Workshop
We’re hosting a session on Harness Engineering to move beyond simple prompts and context. It’s about building the constraints that let agents work autonomously.
May 14th, 11am PT. Led by AJ Joobandi (Augment Code). 20 seats, $150.
You’ll learn why agents break, how to design robust success metrics, and walk away with a plug-and-play harness file.
→ Grab your seat here
## Links
- Paper on arXiv (paper, ~45 min read)
- GitHub repo (code, MIT license)
- Agent Debugger blog (background, ~10 min read)
- NexAU framework (substrate the loop runs on)
Follow @AlphaSignalAI for more content like this.
Subscribe at AlphaSignal.ai for daily AI signals. Read by 280,000+ developers.
## Appendix
```
Algorithm 1: AHE outer loop
H_best ← H₀ # bash-only NexAU₀ seed
for t = 1 to N do
T_t ← Rollout(M, H_{t-1}, D, k) # phase 1: k≥2 rollouts per task
T̃_t ← Clean(T_t) # phase 2: drop base64, dedup tool output
if t ≥ 2 then # phase 3: attribute prior manifest, then rollback
V_t ← Attribute(C_{t-1}, T_{t-1}, T_t)
H_{t-1} ← Rollback(H_{t-1}, V_t)
R_t ← AgentDebugger(T̃_t) # phase 4: layered distillation
(H_t, C_t) ← Evolve(H_{t-1}, R_t, V_t) # phase 5: workspace edits + new manifest
Commit(H_t, C_t, t) # phase 6: tag iteration in git
if Pass@1(T_t) > Pass@1(H_best) then
H_best ← H_t
return H_best
```
## 相关链接
- [AlphaSignal AI](https://x.com/AlphaSignalAI)
- [@AlphaSignalAI](https://x.com/AlphaSignalAI)
- [28K](https://x.com/AlphaSignalAI/status/2049900160080077229/analytics)
- [Harness Engineering workshop](https://luma.com/t24o902x)
- [here](https://lu.ma/t24o902x)
- [Paper on arXiv](https://arxiv.org/abs/2604.25850)
- [GitHub repo](https://github.com/china-qijizhifeng/agentic-harness-engineering)
- [Agent Debugger blog](https://dawning-road.github.io/blog/agent-debugger)
- [NexAU framework](https://github.com/nex-agi/NexAU)
- [@AlphaSignalAI](https://x.com/@AlphaSignalAI)
- [AlphaSignal.ai](https://alphasignal.ai/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:14 AM · May 1, 2026](https://x.com/AlphaSignalAI/status/2049900160080077229)
- [28K Views](https://x.com/AlphaSignalAI/status/2049900160080077229/analytics)
- [View quotes](https://x.com/AlphaSignalAI/status/2049900160080077229/quotes)
---
*导出时间: 2026/5/17 15:25:30*
---
## 中文翻译
# 如何在不触碰模型或提示词的情况下让编码代理更聪明
**作者**: AlphaSignal AI
**日期**: 2026-04-30T17:14:18.000Z
**来源**: [https://x.com/AlphaSignalAI/status/2049900160080077229](https://x.com/AlphaSignalAI/status/2049900160080077229)
---
一篇新论文实现了对编码代理的工具、中间件和记忆的自动进化。它在 32 小时内击败了所有人工调优的配置。
仅修改系统提示词甚至会导致性能倒退。如果将其作为唯一的调整手段，在 Terminal-Bench 2 上的 pass@1 分数会下降 2.3 分。
AHE（代理配置工程，Agentic Harness Engineering）是得出这一发现的框架。它保持基础模型不变，基于实际运行轨迹自动演化全部七个配置组件，并在十次迭代中将仅含 bash 的种子配置从 69.7% 提升至 77.0%。
该结果在 32 小时内，在相同的 89 任务面板上击败了人工设计的 Codex-CLI（71.9%）、仅提示词自演化器 ACE（68.9%）以及轨迹反馈基线 TF-GRPO（72.3%）。
迁移过程直接复用进化后的工作空间，无需任何更改：在 SWE-bench-verified 上消耗的 token 减少了 12%，在另外四个模型族上提升了 5.1 至 10.1 个百分点，其中在基础模型最弱的情况下收益最大。
> “如果您没完全听懂上面的介绍，一定要来看看我们的 Harness Engineering 研讨会。如果您已经跟上了，也还是应该看一看！” 文末有更多详情。
## 背景
这篇论文由复旦大学、北京大学的林嘉航、刘世春、潘承钧及其合作者撰写，题为“Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses”（代理配置工程：可观测性驱动的编码代理配置自动演化）（arXiv 2604.25850，2026 年 4 月 28 日，MIT 许可代码）。
编码代理的配置指的是模型之外的所有内容：系统提示词、工具定义、中间件、技能、子代理、记忆。生产团队通过检查轨迹和编辑文件来进行手工微调。这种人工循环速度缓慢，且收益分散在许多未被记录的决策中。
之前的自动化工作通常一次只优化一个组件，几乎总是优化提示词或上下文中的剧本（ACE, GEPA, DSPy），或者是轨迹分布（TF-GRPO, GRPO 变体）。工具、中间件和记忆往往保持封闭。
AHE 将完整的配置作为一个组合整体进行演化，并将每一次编辑视为一份可证伪的合约，根据下一轮的任务结果进行验证。
## AHE 的工作原理
核心的设计决策在于，循环的每个阶段都会产生结构化的、文件级的人工产物，供另一个代理读取。
**组件可观测性**。配置在 NexAU 框架上实例化，该框架将七种可编辑的组件类型作为文件暴露在固定的挂载点上：系统提示词、工具描述、工具实现、中间件、技能、子代理配置和长期记忆。每种失败模式都清晰地映射到一个组件类。每个逻辑上的编辑都会变成一次 git 提交，因此文件级差异和回滚是现成的。
种子配置故意做得极简，只有一个单一的 bash 工具，没有中间件或技能，因此循环添加的每个组件都必须根据测量的运行结果证明其价值。
**经验可观测性**。Agent Debugger 框架将原始的运行轨迹（数百万个 token）提炼为分层证据语料库。每个轨迹消息都存在于自己的文件中。针对每个任务的根因报告会识别失败模式。
基准级别的概述将每个报告聚合成进化代理的入口点。原始轨迹仍可访问以供验证，但绝不是首选的阅读对象。
**决策可观测性**。每次编辑都会附带一个 change_manifest.json 条目，说明它所解决的失败模式、预测的任务修复、潜在的退化以及约束级别（提示词、工具描述、工具实现、中间件、技能）。
在下一轮中，循环会将预测的修复和退化与观察到的任务级差异进行比对。预测未兑现的编辑将在文件粒度上自动回滚。自我辩解变成了度量。
## 外层循环
简单的伪代码包含在文末的附录部分
关键的抉择在于归因在提炼之前运行。先前编辑的定论存放在进化代理读取的证据语料库中，将每个清单条目绑定为合约而非理由。
进化代理仅在 workspace/ 目录内写入。runs 目录、tracer、verifier 和 LLM 配置是只读的。种子系统提示词不可删除。
这些限制阻止了不受约束的自我修改器可能采取的捷径（例如禁用验证器或增加推理预算），并确保每一个记录下来的收益都归因于配置的编辑。
## 证据
在 Terminal-Bench 2 上进行的十次 AHE 迭代（89 个任务，k=2 次运行，GPT-5.4 高推理模式，总运行时间约 32 小时）将 pass@1 从 69.7% 提升到了 77.0%。AHE 超过了三种人工设计的配置（opencode 47.2%, terminus-2 62.9%, Codex-CLI 71.9%）和两种自进化基线（ACE 68.9%, TF-GRPO 72.3%）。
在简单和中等层级上，AHE 遥遥领先。在困难层级上，它滑落至 53.3%，落后于 Codex-CLI 的 56.7%，这被追溯到是组件干扰而非能力缺失。
跨基准迁移无需重新演化即可保持。在 SWE-bench-verified（跨七个仓库的 500 个任务）上，AHE 获得了最高的总分 75.6%，同时使用的 token 比种子配置少 12%，比 TF-GRPO 少 21%，比 ACE 少 32%。
收益集中在 django 和 sphinx-doc 这两个最大、最耗 token 的仓库上。SWE-bench 上的成本效率：AHE 1.64，NexAU₀ 1.43，TF-GRPO 1.27，ACE 1.10。
跨模型迁移是配置编码通用工程经验的最有力证据。同一个进化后的工作空间，在五个不同的基础模型上不加改动地进行评估，产生了五次正向提升：deepseek-v4-flash 上 +10.1pp（51.7→61.8），qwen-3.6-plus 上 +6.3pp（56.2→62.5），gemini-3.1-flash-lite-preview 上 +5.1pp（36.5→41.6），以及在 GPT-5.4 medium 和 xhigh 上各 +2.3pp。
较弱的基础模型受益更多，因为它们依赖于 AHE 在工具、中间件和记忆中固定的协调模式。较强的模型可以廉价地从提示词中重新推导出相同的协调逻辑。
组件消融实验是关键的发现。将单个 AHE 组件交换到仅含 bash 的种子中：仅记忆 +5.6pp，仅工具 +3.3pp，仅中间件 +2.2pp，仅系统提示词 −2.3pp。ACE 和 TF-GRPO 从未编辑过的配置组件，恰恰正是收益所在。
## 四个案例研究
论文追踪了第 2、5、6 和 8 轮迭代中从失败到修复的四条轨迹。当前最佳曲线中的每个峰值都与一条轨迹相对应。
**db-wal-recovery（第 2 轮）**。代理必须从损坏的预写日志中重建 SQLite 数据库。失败的运行通过猜测的模式（value = id × 100）编造了缺失的行，并根据行数进行自检，而不是验证器要求的值断言。
修复方法是在系统提示词中追加了 68 行内容，包含八条编号规则：契约优先、镜像评估器、在不过拟合可见样本的情况下进行泛化。这些规则都没有提及 SQLite、WAL 或该任务。这些规则最初是为另一组部分通过的任务提出的，后来被意外继承，将 db-wal-recovery 从 1/2 翻转为 2/2，并在随后的每次迭代中保持了 2/2。
**path-tracing（第 5 轮）**。代理渲染了正确的图像，进行了自检，然后发出 rm -rf 作为最后的清理步骤，并依据清理操作的退出代码提交结果。验证器在磁盘上什么也没找到，拒绝了该运行。种子提示词虽然有关于不破坏已验证状态的建议，但没有运行时机制强制执行。
第 5 轮的修复在 shell 工具内安装了一个发布状态守卫：当 shell 观察到成功的评估器风格检查时，它会解析接受命令以获取受保护路径，并拦截后续的删除操作。任务从 0/2 翻转为 2/2。
**mcmc-sampling-stan（第 6 轮）**。代理通过网格积分计算了虚假的后验概率，将真正的 MCMC 运行作为后台任务启动，在收敛前将其终止“以保存交付成果”，并提交了虚假结果。这连续失败了五次迭代。
第 6 轮通过两个组件协同工作解决了这个问题：发布状态守卫扩展为保护脚本入口点（analysis.R），以及一个新的 ExecutionRiskHintsMiddleware，它监视实时命令历史记录中的七种跨步骤风险模式（代理验证器、浅层验证、仅本地主机检查、针对同一错误的重复重试等）。任务从 0/2 翻转为 2/2 并保持。
**configure-git-webserver（第 8 轮）**。代理启动了一个正常工作的 Web 服务器，通过本地主机 curl 进行了自检，然后发出带有 ALLOW_POST_SUCCESS_RESET 前缀的清理命令，擦除了实时 Web 根目录并重置了 git ref，“以便为评分留下一个干净的仓库”。外部验证器收到了 404。
第 8 轮修补了覆盖令牌：删除受保护的输出和重置受保护的根目录变成了硬性阻塞，令牌无法再擦除它们。一个 before_model 钩子将执行风险警告提升为 FRAMEWORK 提醒，在下一个模型轮次中可见。第 8 轮的总分达到了 76.97，是该运行的最高纪录。
这四个案例的通用模式是：提示词说明要避免什么，但运行时的强制执行才是改变结果的关键。四个成功修复中有三个是在工具实现或中间件层面完成的。
## 局限性
**困难层级的落后**。AHE 在困难层级上略逊于 Codex-CLI（53.3% vs 56.7%）。记忆、中间件和系统提示词都倾向于相同的闭包式验证，这在冗余的重新检查上消耗了轮次预算。仅将 AHE 的长期记忆交换到种子配置（没有其他组件）就已经在困难层级上超过了 Codex。
**非加性组件交互**。三个正向的单组件收益加起来是 +11.1pp，但完整的 AHE 仅实现了 +7.3pp。堆叠组件损失了 3.8pp。进化代理优化的是一个由 55 个中等任务主导的聚合指标，因此它收敛为一个倾向于中等的权衡，部分放弃了困难层级记忆的效果。
**回归预测的盲目**。在九轮评估中，进化代理发出了 43 个独特的回归预测，只有 5 个成真（精确率 11.6%）。实际上发生了 40 个未预见的回归（召回率 11.1%）。修复预测比随机高出 5 倍。回归预测仅比随机高出 2 倍。
代理可以证明为什么编辑应该有帮助。它无法可靠地指出同一个编辑会破坏什么。
**基准范围**。完整的演化运行是在 Terminal-Bench 2 上进行的。跨基准和跨模型的迁移证据令人鼓舞，但非 Terminal-Bench-2 的演化运行才是能回答“刷榜”问题的关键。作者指出了这一点，并将其称为泛化风险。
因此，最佳的建议是将 AHE 视为一个受控的研究原型，它已经产生了一个值得研究的冻结配置，同时等待在第二个基准上进行演化运行，然后再将该框架作为生产级自我改进循环采用。
## AlphaSignal 观点
值得关注。该框架名副其实，其凭据（变更清单 + 自动回滚）用度量取代了自我辩解，跨模型迁移是迄今为止最有力的信号，表明配置结构编码了较弱的基础模型无法廉价重新推导的协调模式。
两个未完成的拼图是回归预测的盲目性缺口和第二个基准的演化运行。解决其中任何一个都能将其从研究原型推向生产级。
值得关注的未来实体是 NexAU，即循环运行的基础设施，因为该框架的覆盖范围随有多少生产代理采用文件级组件合约而扩展。
## 谁受益，谁不受益
受益者：在多步骤终端或仓库工作流中运行长期编码代理的团队，任何进行超出粗略初稿的手工提示词微调的人，评估自演化循环作为微调替代方案的 ML 工程师，以及研究不需要梯度更新的测试时适应性表面的研究人员。
跳过者：代理循环是短视界 API 调用链的团队，没有运行轨迹或带有二进制通过/失败信号的验证器的人，以及已经投资于仅提示词框架（ACE, GEPA, DSPy）且无法打开收益所在的配置组件的团队。
## 从业者启示
ML 工程师现在可以针对基准自动进化编码代理的工具、中间件和记忆，因为可观测性原语将每个组件编辑变成了一个可证伪的合约。
## 研讨会
我们正在举办一场关于 Harness Engineering 的会议，旨在超越简单的提示词和上下文。这是关于构建让代理自主工作的约束。
5 月 14 日，上午 11 点（PT）。由 AJ Joobandi（Augment Code）主持。20 个席位，150 美元。
您将了解代理崩溃的原因，如何设计稳健的成功指标，并带走一个即插即用的配置文件。
→ 在此抢座
## 链接
- arXiv 上的论文（论文，约 45 分钟阅读）
- GitHub 仓库（代码，MIT 许可）
- Agent Debugger 博客（背景，约 10 分钟阅读）
- NexAU 框架（循环运行的基础设施）
关注 @AlphaSignalAI 获取更多此类内容。
在 AlphaSignal.ai 订阅以获取每日 AI 信号。超过 28 万开发者阅读。
## 附录
```
算法 1：AHE 外层循环
H_best ← H₀ # 仅含 bash 的 NexAU₀ 种子
for t = 1 to N do
T_t ← Rollout(M, H_{t-1}, D, k) # 阶段 1：每个任务 k≥2 次运行
T̃_t ← Clean(T_t) # 阶段 2：删除 base64，去重工具输出
if t ≥ 2 then # 阶段 3：归因先前列表，然后回滚
V_t ← Attribute(C_{t-1}, T_{t-1}, T_t)
H_{t-1} ← Rollback(H_{t-1}, V_t)
R_t ← AgentDebugger(T̃_t) # 阶段 4：分层提炼
(H_t, C_t) ← Evolve(H_{t-1}, R_t, V_t) # 阶段 5：工作区编辑 + 新清单
Commit(H_t, C_t, t) # 阶段 6：在 git 中标记迭代
if Pass@1(T_t) > Pass@1(H_best) then
H_best ← H_t
return H_best
```
## 相关链接
- [AlphaSignal AI](https://x.com/AlphaSignalAI)
- [@AlphaSignalAI](https://x.com/AlphaSignalAI)
- [28K](https://x.com/AlphaSignalAI/status/2049900160080077229/analytics)
- [Harness Engineering workshop](https://luma.com/t24o902x)
- [here](https://lu.ma/t24o902x)
- [Paper on arXiv](https://arxiv.org/abs/2604.25850)
- [GitHub repo](https://github.com/china-qijizhifeng/agentic-harness-engineering)
- [Agent Debugger blog](https://dawning-road.github.io/blog/agent-debugger)
- [NexAU framework](https://github.com/nex-agi/NexAU)
- [@AlphaSignalAI](https://x.com/@AlphaSignalAI)
- [AlphaSignal.ai](https://alphasignal.ai/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:14 AM · May 1, 2026](https://x.com/AlphaSignalAI/status/2049900160080077229)
- [28K Views](https://x.com/AlphaSignalAI/status/2049900160080077229/analytics)
- [View quotes](https://x.com/AlphaSignalAI/status/2049900160080077229/quotes)
---
*导出时间: 2026/5/17 15:25:30*