meng shao@shao__meng · 6月20日51

有密码保护的文档，怎么解析？ 这在企业 AI Agent 场景，也是一个绕不过去的问题，看看 LandingAI ADE 密码保护文档解析方案，怎么解决它？ 它支持在同一次请求中完成：解密 → 解析 → 结构化输出。只需在 Parse 或 Parse Jobs 调用里传入 password，无需在本地先解密再上传。 前置条件：必须开启 ZDR 该能力仅对已启用 Zero Data Retention（零数据留存）的组织开放。 ZDR 的含义： · 文档仅在内存中处理，不落盘、不持久化 · 处理完成后立即丢弃，不用于模型训练 · 面向 HIPAA、PHI/PII 等合规场景 为什么和密码解析绑定？ 密码本身属于敏感凭证；在 ZDR 模式下，解密与解析在同一受控、无留存链路中完成，降低密码与明文内容被长期存储的风险。 支持的格式 · PDF：.pdf · 文本文档：.doc, .docx, .odt · 演示文稿：.ppt, .pptx · 电子表格：.xlsx 工程与安全要点 · 集成成本：单一可选参数，对非加密文件无影响 · 错误处理：缺密码 → 422，需在调用前判断或捕获 · 密码传输：经 HTTPS；ZDR 下服务端不持久化；仍建议最小权限 API Key、审计日志 · 与 ZDR 联动：开启 ZDR 后，单次只能传一个文件；Parse Jobs 须配合 output_save_url

译LandingAI Agentic Document Extraction（ADE）现支持在 Parse 或 Parse Jobs 调用中传入 password 参数，同一请求完成解密、解析及结构化输出。该功能要求启用 Zero Data Retention（ZDR）模式，文档仅在内存处理，不持久化，适用于 HIPAA/PHI/PII 合规场景。支持 PDF、DOC、DOCX、ODT、PPT、PPTX、XLSX 格式。集成成本低：单一可选参数，非加密文件不受影响；缺密码返回 422 错误。密码经 HTTPS 传输，ZDR 下服务端不持久化，建议配合最小权限 API Key 与审计日志。REST API 及 Python/TypeScript 库均可用。

宝玉@dotey · 6月20日60

一点不同意见。 如果是程序发生了错误，那首先这是代码问题，代码问题不一定是 Codex 的锅。你让它再怎么改 AGENTS.md，也不见得下次就不会犯同样的错误。 从软件工程的角度来说，通常处理错误的顺序是这样的： 1）恢复生产 先恢复再找原因，尤其是线上紧急问题。要么回滚要么打补丁，先把生产恢复了再说。但也要注意保留日志和现场，方便后续追查。 2）找根因 错误发生了，找 Root Cause 是必须的。到底是逻辑错误、边界条件没处理、还是对需求理解有偏差？不同的根因，对应不同的解法。 3）避免再次发生 这一步当然没问题，但怎么做有讲究，不是一句更新 AGENTS.md 就能解决所有情况的。 比如边界条件没覆盖，那就加测试用例；代码架构有缺陷，那就重构；Code Review 流程有漏洞，那就改进 review 流程。具体怎么做，要根据根因来定。 那什么情况下才应该更新 AGENTS.md？ 当错误的根因是 AI 对项目特有的约定或上下文缺乏了解的时候。 比如项目有特定的命名规范或目录结构约定，代码里看不出来； 比如某些 API 有隐含的使用限制，文档里没写清楚； 比如团队有特殊的测试规范或提交规范。 这些属于项目知识，写进 AGENTS.md 是合理的。 但如果一个 bug 应该靠测试来防，那就写测试；应该靠 Code Review 来防，那就改流程。把什么都往 AGENTS.md 里塞，反而会让它变得大而无用还占 Token，规则越多越不精准，AI 反而更容易忽略真正重要的那几条。

译宝玉认为处理错误应先恢复生产（回滚或打补丁，保留日志），再找根因（逻辑错误、边界条件、需求理解偏差），最后根据根因决定如何避免。仅当根因是AI对项目特有约定缺乏了解时（如命名规范、API隐含限制、团队测试规范），才应更新AGENTS.md。其他情况应分别用新增测试用例、重构架构、改进Code Review等方式解决。将一切塞入AGENTS.md会导致文件臃肿、规则繁多，AI反而忽略关键规则。

AYi@AYi_AInotes · 6月20日52

GPT-5.6 Pro 泄露了，大概下周四发布， 发现大家都在讨论Juice Value 960 又涨了多少，但如果你把视觉复刻、SVG 3D、Playwright 浏览器自动化这三个词连起来看，会发现一件很重要的事， OpenAI 在尝试把 GPT 从脑子变成手， 先看这三个词各自说了什么， 视觉复刻已经做到"几乎可以复刻设计"，以前 GPT 能描述你的设计哪里不对，现在它能直接复刻一个给你看 SVG 3D 生成表现优异，甚至超越了 Fable 5——不是生成一张静态图就完事儿，能生成可以在浏览器里旋转缩放的三维对象， Playwright 浏览器自动化，这是最容易被忽略的技术点， ChatGPT 现在都能打开浏览器了̋(ˊ•͈ꇴ•͈ˋ) 不是假装打开，是真正操作网页：点击、输入、跳转、抓取 这三个词放在一起指向的已经不只是一个更强的语言模型了，已经是一个能做物理动作的 Agent 了， 以前 OpenAI 的比赛是谁的脑子最聪明，现在这场比赛多了一个项目：谁的手最稳 一个能和你聊天、告诉你该怎么做的人，现在能打开你的浏览器，移动你的鼠标，复制一个设计，生成一个 3D 图标，保存到桌面上。脑子还是那个脑子，但他已经长出手了

译GPT-5.6 Pro 预计下周四发布，泄露信息显示其三项关键能力：视觉复刻已近乎能完全复刻设计；SVG 3D 生成表现超越 Fable 5，支持浏览器内旋转缩放；Playwright 浏览器自动化可真实操作网页（点击、输入、跳转、抓取）。这三项能力表明 OpenAI 正将 GPT 从语言模型进化为能执行物理操作的 Agent——不仅能“思考”，还能打开浏览器、移动鼠标、复制设计并保存到桌面。

meng shao@shao__meng · 6月20日63

驾驭 Claude Code：CLAUDE.md 配置文件、Skills、Hooks、Rules、Subagents 等 7 种指令全解析 Claude Code 最新博客，围绕七种方法展开： CLAUDE.md 文件、Rules、Skills、Subagents、Hooks、Output Styles、Appending the System Prompt。 每种方式的本质差异体现在三个维度： · 何时加载进上下文 · 会话压缩后是否保留 · 消耗多少 token、权威性如何 https://claude.com/blog/steering-claude-code-skills-hooks-rules-subagents-and-more 1. CLAUDE.md 文件 项目根目录下的 Markdown 文件，是最基础的配置层。 分两类加载：根目录 CLAUDE.md 在会话开始时全程驻留上下文，压缩后重新读取；子目录 CLAUDE.md 按需加载，仅当 Claude 访问该目录下文件时才触发，压缩后即失效。 关键警示：在共享仓库中，CLAUDE.md 往往像任何无人负责的配置文件一样，各团队不断追加内容却从不删减，成本在规模上会持续累积。每一行都会加载进每位工程师的每次会话，无论与当前任务是否相关。 claude 官方建议：控制在 200 行以内，指定负责人，像审查代码一样审查变更。 2. Rules 存放在 .claude/rules/ 的 Markdown 文件。 最有价值的特性是路径作用域：通过 paths 字段控制仅在触碰特定文件时才加载。例如只在 src/api/** 被访问时才注入"所有 API 处理器必须用 Zod 验证输入"的规则，而不是全程占用 token。 无 paths 限定的规则，行为等同于 CLAUDE.md——始终在场，始终消耗。 3. Skills 存放在 .claude/skills/ 的程序化工作流。 设计精妙之处：会话开始时只加载名称和描述；完整内容仅在技能被调用时才载入，可通过斜杠命令或任务自动匹配触发。 适合封装部署流程、发布检查清单、代码审查流程等固定程序，而非塞进 CLAUDE.md。Claude Code 自带若干内置 Skills，也支持自定义。 4. Subagents 存放在 .claude/agents/ 的独立助理定义。 与 Skills 的关键区别在于隔离性：子智能体在自己独立的全新上下文窗口中运行，返回给主会话的只有最终消息（通常是多个子任务的聚合结果）加上元数据，中间过程完全不污染主会话。 适合"跑完就丢"的旁路任务：深度搜索、日志分析、依赖审计。子智能体最多可嵌套五层深，支持动态编排数十到数百个后台 Agent 并行运作。 Skills vs Subagents 选择原则：想在主线程中逐步看到、随时干预 → Skills；想要隔离运行、只要最终结论 → Subagents。 5. Hooks 注册在 settings.json 中，在 Claude 生命周期的特定事件上触发（文件编辑、工具调用、会话开始等）。 这是确定性控制的唯一真正实现：Hooks 完全绕过上下文压缩机制，配置本身存在于主上下文窗口之外，因此上下文成本极低。 支持 command、HTTP、mcp_tool（确定性执行）和 prompt、agent（用模型判断）五种类型。一个 PreToolUse hook 可以拦截任何工具调用，以 exit code 2 阻止其执行。 重要观点：凡是写在 CLAUDE.md 里的"永远不要做某事"，都是错误的工具选择。Claude 大多数时候会遵守，但在长会话、模糊情况或遭遇提示词注入时可能失效。真正的硬约束必须是确定性的，而 Hooks 和权限控制才是实现方式。 组织级强制管控还可以使用 Managed Settings（管理员部署，用户无法覆盖）。 6. Output Styles 存放在 .claude/output-styles/ 的文件，直接注入系统提示，永不被压缩，权威性最高。 高权威有代价：自定义输出风格默认会替换掉 Claude Code 的默认输出风格，包括"如何界定改动范围、何时添加注释、如何处理安全问题、声称完成前是否运行测试"等关键编程默认指令，使 Claude Code 退化为通用助理。 官方建议先看内置风格（Proactive/Explanatory/Learning），覆盖大多数需求，无需自己维护文件。 7. Appending the System Prompt 通过 CLI flag 在调用时追加，仅对本次调用生效，不跨会话持久化。 与 Output Styles 的区别是只增不替换，不改变 Claude 的角色设定，只是在默认角色上叠加指令。 注意边界：追加系统提示存在边际收益递减问题。提供的指令越多，Claude 的遵从度越低，若指令之间存在矛盾则尤为明显。 几个实用决策原则 1. 每次编辑后自动跑 linter × 写进 CLAUDE.md √ 用 Hook 注册到 PostToolUse 2. 禁止某类危险操作 × "Never do this" 写 CLAUDE.md √ PreToolUse Hook + exit code 2 3. 30 行部署流程 × 塞进 CLAUDE.md √ 放进 .claude/skills/ 4. 只对 API 目录生效的规则 × 无路径限定的 Rule √ 用 paths: 字段作用域限定 5. 个人习惯偏好 × 写进项目级 CLAUDE.md √ 写进用户级配置（对所有仓库生效）

译博客详解 Claude Code 的七种指令配置（CLAUDE.md、Rules、Skills、Subagents、Hooks、Output Styles、追加系统提示），从加载时机、压缩后保留性、token消耗与权威性三个维度对比。CLAUDE.md 分根目录（全程驻留）和子目录（按需加载）；Rules 支持路径作用域节省 token；Skills 仅加载名称和描述，调用时载入完整内容；Subagents 独立上下文运行，只返回结果；Hooks 绕过压缩实现确定性控制；Output Styles 直接注入系统提示且永不被压缩；追加系统提示仅单次生效。文章给出实用决策原则，如用 Hook 跑 lint、用 Skills 封装部署流程等。

swyx@swyx · 6月20日50

I think @AriX @skybysoftware is one of the highest ROI acquisitions @sama ever did

译我认为 @AriX 和 @skybysoftware 是 @sama 做过的最具投资回报率的收购之一。

Tibo@thsottiaux · 6月20日62

Remote / local handoff in Codex! Removing boundaries one at a time. When you let the model be in the driver seat, you actually need less infrastructure.

译Remote / local handoff in Codex! 一步步消除边界。 当你让模型掌握主导权时，实际上需要的底层设施更少。

宝玉@dotey · 6月20日75

Skill 和软件一样，需要不断迭代的，而且你用户越多，遇到的各种问题就越多，就需要去解决各种边边角角的问题，才能越来越好用。 比如 @yangyi 昨天在他的牛马AI里面测试了这个Skill，说导出好像有问题，我拿到结果一看，简直惨不忍睹（图2），这里面有两个问题： 1. 样式表不对，没有铺满整页，只占了一半 2. 导出的渐变色没有了，把图片都遮没了 写 Skill 比写软件有个优势，就是你可以让 Agent 先跑，跑完之后 Agent 它自己知道有哪些上下文，遇到了什么问题，这样它可以分析问题在哪。 于是我在本地跑一次，能重现，再让它分析原因，解决，那么它就能找出原因，并从 Skill 的层面去解决，添加测试覆盖，避免类似的问题再次出现。图1就是修复后的，看起来就好多了。 这其实也是我日常迭代 Skill 的方法： 自己用 -> 发现问题 -> 让 Agent 分析原因 -> 让 Agent 出解决方案 -> 确认方案♻️ -> 更新 Skill -> 自己用 ♻️

译宝玉分享 baoyu-design Skill 的迭代过程：用户测试发现导出问题（样式表未铺满整页、渐变色丢失），他在本地复现后让 Agent 分析原因、给出解决方案并添加测试覆盖，修复后效果改善。该 Skill 可在制作 PPT、动画视频或网站时调用 AI 生图配图，支持 Codex 内置画图或配合 baoyu-image-gen Skill 调用 Codex CLI 画图，并能连同图片一起导出为 PPTX，在 PowerPoint/Keynote 中二次编辑。迭代循环：自己用 → 发现问题 → 让 Agent 分析 → 出方案 → 确认 → 更新 Skill。

AYi@AYi_AInotes · 6月20日61

卧槽看完这个帖子我真的惊呆了， Theo让Codex通宵打扫GitHub的僵尸PR坟场，自己踏踏实实睡了一整晚， 我把他这套工作流拆出来了，大家可以直接抄作业， 我翻了下评论区，让 Codex 通宵清理 GitHub 僵尸 PR 这件事，好多人只看到了自动关 PR 的爽感， 其实真正值钱的是——每个被复活的 PR 同时跑了两个线程， 一个 Build 线程负责写代码、更新、修复冲突， 一个 Review 线程负责审查代码， 相当于给每个任务配了一个写手和一个审稿人，单点幻觉风险被结构性降低了， 我把这套玩法拆成三步，现在就能抄： → Triage 分诊：让 AI 先把所有 open PR 过一遍，判断哪些没用、哪些有价值但过时了，这是最耗人类脑力的前置步骤，现在被自动化了 → 关掉无用的：没意义的直接关，不用纠结 → 复活有价值的：给每个还剩一口气的 PR 分配双线程并行推进，人类只在关键节点看一眼 这真的不是简单的工具升级了兄弟们，把仓库维护从一个人的拖延症，变成了一套 agent 排班制度，真他么妙啊， 你睡觉，它上班，你醒来只看决策就行了！ 快去看看你的 GitHub 仓库里有没有压了三年的僵尸 PR，今晚扔给 agent 试试 👇

译开发者 Theo 让 Codex 通宵处理 GitHub 仓库中过时的 PR：自动分诊判断价值，关闭无用的，复活过时的。每个被复活的 PR 同时运行两个线程——Build 线程负责修复冲突和更新代码，Review 线程负责审查代码，形成写手+审稿人的双保险，降低单点幻觉风险。人类只需在关键节点做决策。工作流将仓库维护从个人拖延症转变为 agent 排班制度，实现“睡觉时自动干活，醒来只看决策”。主推文作者拆解出三步：Triage 分诊、关闭无用、复活并行推进，可直接复制使用。

elvis@omarsar0 · 6月20日70

http://x.com/i/article/2068004233849290752 # From Prompting Agents to Loop Engineering A claim has been circulating in AI coding circles: stop prompting your coding agents and start designing loops that prompt them for you. As with everything new, this stuff gets repeated often and explained rarely. This is the practical version: what an agent loop is, why it matters, and what one looks like in production. Below you can read some of my thoughts (written with the help of Claude) from some of the experiments, research, and conversations I’ve been having with some of our students, technical founders, AI engineers, and startups. You might also find our recent live session on "Autonomous Long-Running Coding Agents" as a good starting point for all of this. ## Where the claim comes from > "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents."Peter Steinberger (@steipete), Jun 7 2026. 2.2M views. Original tweet Boris Cherny, the creator of Claude Code, makes the same point from the other side. > "I don't prompt Claude anymore. I have loops that are running. They're the ones that are prompting Claude and figuring out what to do. My job is to write loops."Boris Cherny (@bcherny). Original tweet The point is not that prompt engineering is dead. With loop engineering, the work moves up a level, from writing the code to writing the system that writes the code. Developers furthest along this path report months where they shipped hundreds of PRs without opening an IDE, with every line written by the agent. ## What a loop actually is A loop is a small program you write that does four things: - prompts the coding agent for you, - reads what it produced, - decides whether it is done, - and if not, prompts it again with the error or the next step. You stop sitting inside the loop typing prompts; you write the loop, and the model becomes a subroutine it calls. The shape is always the same: set a goal, act, check, feed the error back, and repeat until the check passes or the loop stops itself. ## "Loop" means at least five things Much of the disagreement is people using one word for five different ideas. Here is the progression, oldest to newest. - ReAct (2022). The original research pattern: reason, act, observe, repeat. - AutoGPT (2023). A self-prompting goal loop, notorious for not knowing when to stop. - ralph loop. A deliberate context reset between iterations so the agent does not drown in its own history. - /loop and /goal. Cadence and completion conditions are built into the agent, carrying the state across turns. - orchestration. One author fans out many agents that read your GitHub, Slack, and chat, and decide what to build next. ## The parts you actually assemble The progression explains what people mean by loop; this is what a loop is built from. The same six parts show up every time, and most now ship inside the coding tools instead of custom scripting you maintain yourself. - A trigger. Something that starts the loop without you pressing go: a schedule, a webhook, a file change, a label landing on a PR. This is what separates a real loop from a single run you repeat by hand. - Isolation. A private checkout per agent, usually a git worktree, so two agents running at once cannot overwrite each other's files. Once you run more than one, this stops being optional. - Written-down context. The conventions, build steps, and project-specific rules are kept where the agent reads them on every run. Skip it, and the loop re-derives your project from scratch each pass and guesses at the gaps. - Reach into your tools. Connectors to the issue tracker, CI, database, and chat, so the loop can open the PR, link the ticket, and post the result instead of printing a fix and waiting for you to carry it the rest of the way. - A second agent checks. A separate worker who grades the output is held apart from the one who produced it, because a model reviewing its own work passes almost everything. - State on disk. A markdown file, a board, or a queue: anything outside the conversation that records what is finished and what is next. The model forgets between runs; the file does not. Assemble those six, and you have a good starting point for loop engineering. You used to hand-build everything; now most ship as built-in features, which is why the pattern has moved from a fringe technique into common use. ## A concrete loop, the PR babysitter A concrete example you can build today: - Trigger. Every 15 minutes. - Scope. Open PRs labeled agent-watch. - Action. If CI is red for a deterministic reason, attempt one fix. If the main moved, rebase once. - Budget. One fix attempt per PR, five minutes, ten files changed. - Stop condition. CI green, or budget exhausted, then stop and ping a human. You return to merged PRs instead of a backlog of broken builds. The same shape covers most ops work: - CI health. Every 30 minutes, pull failing runs and cluster them by signature, so ten red PRs with one root cause become one thing to look at. - Deploy verification. After a push, hit your endpoints, confirm 200s and the expected content, and flag regressions before users do. - Feedback clustering. Every 30 minutes, pull comments from your channels, group them into themes, and map each cluster to the file or doc that owns it. ## A concrete Claude Code loop with /goal The babysitter is a loop you wire up yourself; it also helps to see one that ships inside the agent. In Claude Code, the smallest complete loop is /goal: you hand it a verifiable end state, and it keeps taking turns until that state is true. Here is an example of /goal used as an in-session command in Claude Code. You launch the session, then set the goal inside it: It is the same act, check, repeat shape from earlier, with the verifier built in. At this point, it’s clear that a strong /goal reads less like a prompt and more like a contract. The good ones specify four things: the end state you want, the evidence that proves you reached it, the constraints the agent must not break getting there, and the budget of work it is allowed to spend. Leave any one of them vague, and the model fills the gap with the easiest reading: it stops early, takes a shortcut, or redefines success so the transcript looks done while the real system is broken. - Set the condition. Type /goal plus a checkable end state, for example,/goal tests in test/auth pass. The first turn starts immediately. - The agent works a turn. It edits, runs the tests, and surfaces the results in the session. - An evaluator checks. A fast model reads the transcript and decides whether it is met or not met, so the agent is not grading its own work. - Loop or finish. Not met means another turn with guidance; met means the goal clears itself and the run stops. State carries across turns, so it does not quit early or drop a constraint partway through. A few controls keep it reliable: - Make the check measurable. A test result, an exit code, a file count, or an empty queue. npm test exits 0 is a goal; "make it better" is not. - Bound the run. Append something like "or stop after 20 turns" so a stuck loop halts instead of burning turns. - Pair it with auto mode so that turns run unattended, and use /goal clear to abandon it early. The evaluator step hides a useful subtlety: the checker does not have to be the same model as the coder. Once the loop has distinct roles (planner, executor, evaluator, vision reviewer), each can run on a different model, and choosing which model fills which role becomes an architecture decision rather than a single bet on one "best" coding agent. Some models plan better, some execute more cheaply, some judge a screenshot more accurately, and a good orchestrator lets you swap them per role instead of waiting for one vendor to win every category. It works well for API migrations (move every call site until it compiles and tests pass), refactors (split a file until each module is under budget), issue backlogs (work a labeled queue until it is empty), and eval loops (tune a prompt until the score clears a threshold). /loop is the counterpart for work with no single finish line: instead of a completion condition it re-prompts on a schedule, which is how a loop like the PR babysitter keeps running. ## Running many loops unattended A single /goal loop is one agent working toward one finish line. Running many unattended processes raises the stakes, because a loop is only as trustworthy as its ability to check its own work. Cherny's setup for running Opus autonomously for hours comes down to five steps: 1. Auto-approve permissions so the agent does not stop to ask on every tool call. 1. Use dynamic workflows (drop Ultracode into the prompt) to fan out across many agents instead of one serial thread. 1. Use /goal or /loop to keep it going. /goal sets a completion condition, /loop re-prompts on a schedule, and both carry state, so it does not quit early. 1. Run it in the cloud (desktop or mobile app) so the session survives when you close the laptop. 1. Give it a way to self-verify end-to-end. Claude in Chrome for web, a simulator MCP for mobile, and a live server for backend. This is the step that makes the other four safe. The full sequence: ## crabfleet: orchestration as a product Orchestration is easier to picture with a concrete tool. Peter Steinberger's crabfleet, an OpenClaw project billed as "mission control for agent runs," is a loop packaged as a product, and its shape maps onto everything above. - Work as cards on a board. Tasks are entered as cards built from a prompt, a GitHub issue, or a PR, then move through todo, running, human review, and done. That board is the loop's queue and its stop-and-report step, made visible. - Durable runs, not fire-and-forget. Each run is a tracked attempt with heartbeats, so it keeps going when you look away and survives a closed laptop. You take over only when the runtime advertises that it supports handoff. - Agents that spawn agents. A run can start child sessions, send messages, read transcripts, and update its own summary from inside a sandbox: on-disk memory and fan-out in one place, one author and many agents. It runs on disposable cloud sandboxes with browser-based terminals, which is what makes walking away from an unattended run safe. The point is not the specific tool but that the loop has hardened into infrastructure: a queue, durable execution, fan-out, and a human-review gate are now things you configure rather than hand-script every time. ## Where the cost goes now For two years, the cost question in AI coding was simple: which model, and how many tokens. Inside a loop, that instinct points at the wrong layer. The spend is no longer a single call but how many times the loop goes around, so a loop that retries six times before it converges costs six times as much as one that lands on the first pass, on the same model. That changes what is worth optimizing: - Iterations are the budget line, not tokens. A cheaper model that loops twice as often is not cheaper, so track cost per finished task, not cost per call. - A weak verifier is the most expensive bug you can ship. If the check that decides "done" is loose, the loop either stops early on broken work or grinds on work that was already fine, and both waste whole iterations. Tighten this before anything else. - Failing fast is a cost control. A loop with no cap on consecutive failures does not eventually succeed; it eventually drains the account, so the stop condition protects the bill as much as the codebase. You used to tune the prompt; now you tune the loop, because that is where the cost accumulates. ## When not to loop Loops pay off when a task repeats, and a machine can tell when it is done. Outside that, a loop only automates churn. Skip it in these cases: - One-shot edits. If you can finish it in a single pass, a loop is pure overhead. - Unscoped or exploratory work. "Figure out why users are churning" has no pass condition, so the loop never converges. - Anything without a cheap automated check. If the only verifier is your own eyes, you are still inside the loop. Build the check first, or do the task by hand. ## What can go wrong A loop that runs while you sleep also makes mistakes while you sleep, and the failure modes are predictable. - The verification burden stays human. The loop writes faster than you can review, so if you stop reading the diffs, you have not removed the work, only deferred it. - Comprehension gaps widen. Shipping code you did not write, faster than you can absorb it, erodes the model of your own system, and that debt comes due during the next incident. - Silent drift on a loose check. A weak verifier lets wrong-but-passing work through on every iteration, so the loop looks productive while it digs a hole. None of this is an argument against loops; it is why the engineer who designs the loop matters more, not less. ## How to build your own 1. Pick one repeatable task. Babysitting PRs, fixing CI, verifying deploys: start with routine work. 1. Scope it tight. "Fix the billing webhook validation, only touch app/api/billing and lib/billing," beats "fix the bug." A loose loop wanders. 1. Give it a budget and a stop condition. Max attempts, max runtime, max files, max spend, max consecutive failures. A loop running unattended is also a loop making mistakes unattended. 1. Add an independent verifier. A separate sub-agent grades the work, because the agent who wrote the code is the worst judge of whether it is done. 1. Run it on a cadence. /loop for an interval, cron for a schedule, hooks at lifecycle points, or GitHub Actions so it survives a closed laptop. 1. Keep memory on disk. The model forgets between runs, so state lives in markdown or a board, not in the context window. The takeaway: the loop, not the model, is now the expensive and failure-prone part. Build it like someone who intends to stay the engineer responsible for the output, not just the person who starts the run. If you see any errors or things that need further clarification, don’t be afraid to reach out. ## Other Useful References - Addy Osmani (@addyosmani), on AI-assisted coding loops - Matt Van Horn (@mvanhorn), "WTF Is a Loop?" - Peter Steinberger (@steipete), on designing loops - Boris Cherny (@bcherny), on running agents autonomously

译AI编程圈出现新主张：不应再手动提示编码智能体，而应设计循环自动完成提示、读取输出、判断完成，并在出错时重新提示。Boris Cherny（Claude Code创建者）和Peter Steinberger均持此观点。文章梳理了循环的五种演进形态（ReAct、AutoGPT、ralph loop、/loop与/goal、编排），并拆解六大组装部件：触发机制、隔离工作区、项目上下文记录、工具连接、独立验证智能体等。核心转变是从编写代码升级到编写驱动代码的系统。

elvis@omarsar0 · 6月20日22

Had so many thoughts on the "loop engineering" trend. I spent a few minutes with my writer agent to summarize some of my research, notes, and discussions with students, founders, and startups. Very early, but new ways of working with agents will start to emerge with a step-change in capabilities.

译对“循环工程（loop engineering）”趋势有许多想法。 我用我的写作智能体花了几分钟总结了我的一些研究、笔记以及与学生们、创始人们和初创公司的讨论。 还处于非常早期，但智能体的新工作方式即将出现，能力将有阶跃式变化。

Berryxia.AI@berryxia · 6月20日57

http://x.com/i/article/2067984320212668416 # 搭一个AI Agent团队，到底有多难！5分钟搭的是玩具，不是员工。 你大概也刷到过那种教程——“5分钟搭一个 AI Agent 团队”，评论区清一色“收藏了”“这就去试”。你收藏了，你也试了，然后卡在了第一步。 不是因为你不够聪明。 从“看懂教程”到“跑通一个能干活的 Agent 团队”之间，横着四道真实的技术门槛。每一道都有人折在上面，每一道短期内都不会自动消失。 最近在 X 上传播最广的一篇，是 Khairallah AL-Awady 写的“How to Build Your First Team of AI Agents Using Claude”，万级浏览，承诺很诱人：大多数人还在一问一答地用 Claude，少数人已经让 AI 跑起了整个团队。 但打开教程动手试的人，大概率都经历了同一件事：卡住。 这篇文章不喊“未来已来”，也不贩卖焦虑。只想把四道门槛逐层拆开，讲清楚到底难在哪。 看完之后，你不只是松口气，还能带走一个判断标准：下次再看到“5分钟搭 AI 员工”的噱头，一眼就知道它靠不靠谱。 ## 第一道槛：环境配置，劝退率最高的隐形墙 搭 Agent 团队的第一步不是设计架构，而是把开发环境跑起来。就这一步，能劝退八成的人。 如果你不是全职开发者，光是看懂接下来这串名词就要查半天：Python 3.10+、Anaconda 环境管理、PyTorch 框架、API Key 配置（OpenAI/Claude/Gemini 三选一还是全要？）、向量数据库、Docker 容器化…… 清华大学出版社的《AI Agent 智能体开发实践》用整整一章讲“Agent 开发环境配置”，步骤密集得像一份工程手册。 CSDN 上“从零搭建 AI Agent”的教程评论区，出现频率最高的反馈是：环境配了一整天跑不起来。 更让人头疼的是框架选择。 Anthropic Agent SDK、OpenAI Agents SDK、LangGraph、CrewAI，四个主流框架，设计哲学各异，选错之后的迁移成本极高。 而 MCP 协议刚出来，A2A 协议还在早期，不同框架之间的互操作性几乎为零。今天选的框架，半年后可能就是技术债。 低代码平台（扣子/Coze、Dify）正在降低入门门槛，但只能覆盖简单场景。一旦需求复杂化，你还是得回到代码层。 环境配置这道槛，本质上不是“难”，而是“碎”。每一步都不难，但步骤太多、依赖太杂、标准太乱，拼起来就是一堵墙。 ## 第二道槛：Agent 编排，让 AI 协作比让 AI 干活难十倍 环境配好了，接下来要解决的是：怎么让多个 Agent 分工协作？ 直觉上，这不过是“给每个 Agent 一个角色，让它们各干各的”。 但 arxiv 上的多篇论文给出了更冷峻的结论：多 Agent 协作存在三个系统性缺陷，从众效应、角色不一致、臆想拼凑。 从众效应指的是，Agent 在讨论中受“同伴压力”影响，放弃自己的判断去附和别人。角色不一致意味着，你给 Agent 定义了“审稿人”的角色，它聊着聊着就变成了“写稿人”。 臆想拼凑则类似人类的记忆偏差，Agent 不是在撒谎，而是真心以为自己编出来的东西是对的——这才是最棘手的部分。 更讽刺的是，鼓励辩论而非协作的指令，反而会加剧这些问题。 传统 plan-and-execute 框架也扛不住。 它的三大局限：僵化的计划执行、静态的 Agent 能力、低效的通信，在复杂任务面前暴露无遗。 斯坦福的研究发现，LLM 作为规划器经常产出不完整或不一致的行动序列，违反约束条件，需要独立验证器、版本化执行日志和局部修复机制才能勉强兜底。 这就引出了一个有意思的立场分歧。 Anthropic 自己构建多 Agent 系统时，采用的是 Subagents 模式，一个主 Agent 调度多个子 Agent，子 Agent 之间互不通信。 这是目前生产环境中唯一稳定的多 Agent 模式。 而 Cognition（Devin 的母公司）更直接，发了一篇标题就叫“Don‘t Build Multi-Agents”的文章，认为应该用上下文工程替代多 Agent 架构。 翻译成人话：连造 Agent 的人自己都不太敢让 Agent 之间自由对话。 多 Agent 编排本质上是分布式系统问题，但 LLM 的非确定性让传统分布式系统的解决方案（共识协议、状态机复制）无法直接套用。 这道槛，不是换个框架能解决的。 ## 第三道槛：上下文管理，Agent 团队的真正杀手 前两道槛好歹还能靠耐心和经验硬扛。上下文管理是另一回事——它是 Agent 团队失败的隐性原因，也是最被低估的那道槛。 Andrej Karpathy 有个比喻：LLM 是 CPU，上下文窗口是 RAM。 RAM 有限，操作系统需要管理内存。上下文窗口有限，同样需要管理什么信息放进去。 问题在于，大多数开发者根本没有“管理上下文”这个意识，他们以为写好 prompt 就够了。 上下文崩塌有四种模式。 上下文污染：错误信息进入上下文后持续污染后续推理，像一行脏数据搞垮整张表。上下文分散：过多无关信息导致模型注意力涣散，该关注的反而被淹没。 上下文混淆：相似但不同的信息让模型分不清谁是谁。 上下文冲突：矛盾的信息直接导致行为不可预测。 在多 Agent 场景中，这四种模式会叠加放大。 每个 Agent 都有自己的上下文，Agent 之间传递信息时，上下文要么膨胀（信息越传越多），要么丢失（关键细节在传递中被压缩掉）。 这不是写几句 prompt 能修补的，这是架构层面的问题。 一个数据足以说明一切：据公开报道，Anthropic 用同一款 Opus 4.5模型，搭配不同的工程适配架构，Claude Code 架构在 CORE 基准上拿到78%，Smolagents 架构只有42%。 模型完全一致，仅上下文工程不同，分差36个百分点。 36个百分点。这意味着上下文工程对结果的影响，可能比换一个更强的模型还大。 另一位实践者报告：采用系统化的上下文工程后，调试周期从5.2天压到1.7天，用户任务完成率从63%跳到89%。当然，这是个案经验，不代表普遍结论，但方向是明确的。 但上下文工程不是“更高级的 prompt 写法”，而是把整个交互过程当作可建模、可测量、可版本化的工程系统。 这套方法论目前还在早期，没有成熟工具链，没有最佳实践共识，甚至没有统一的定义。 Spring AI Alibaba 的 Agent 抽象层专门为此设计，承认“缺乏正确的上下文是更可靠 Agent 的头号障碍”。 这道槛的残酷之处在于：你不知道自己死在了这里。Agent 跑出来的结果不对，你以为是模型不够强，其实是上下文没管好。 ## 第四道槛：工具接入与稳定性，demo 能跑≠能干活 前三道槛解决的是“能不能跑起来”的问题。第四道槛解决的是“跑起来之后能不能干活”的问题。这两件事之间的距离，比大多数人以为的大得多。 传统软件有合约来规范行为：API 定义输入输出，类型系统约束数据格式，断言和测试兜底边界情况。但 AI Agent 基于 prompt 和自然语言指令运行，没有正式的行为规范。 一篇2026年的 arxiv 论文把这个问题叫做“Agent Behavioral Contracts”——Agent 行为合约的缺失，是漂移、治理失败和项目频繁失败的根源。 翻译成人话：传统软件出了 bug 你知道它错在哪，Agent 出了问题你可能连它怎么偏的都说不清。 实践中，翻车场景花样百出。工具调用失败后 Agent 不知道怎么恢复，陷入死循环。 多个 Agent 同时调用同一个 API 导致冲突。上游 API 悄悄改了接口，Agent 行为静默退化，没有告警，你甚至不知道它已经坏了。 更隐蔽的是成本失控，一个看似简单的任务，可能触发几十次 API 调用，账单比你预想的多一个零。 Nature Scientific Reports 2026年的一项研究发现，在多 Agent 路由中，即便采用置信度感知门控将路由准确率从0.65提升到0.77，切换不稳定性和弹跳不稳定性仍然存在。 翻译成人话：Agent 在“该不该切换到另一个 Agent”这件事上，判断力依然不可靠。 工具生态的碎片化加剧了这个问题。 MCP 协议刚起步，A2A 协议还在早期，缺乏统一的工具描述和调用标准。每接入一个新工具，你都在写一次性的适配代码，而这些代码没有复用价值，也没有人帮你维护。 能跑 demo 和能干活之间，差的是一整套可靠性工程。 ## 回到现实：哪些槛在解，哪些槛还得等 四道门槛拆完了，一个自然的问题是：有人在解决吗？ 环境配置门槛正在被低代码平台吃掉。扣子/Coze、Dify 这类工具让简单场景的 Agent 搭建变成了拖拽操作，不需要碰代码。 但“简单场景”是个限定词，需求一复杂，你还是得回到代码层，回到那些碎片化的依赖和互不兼容的框架里。 单 Agent 编排也在变容易。Anthropic Agent SDK 和 OpenAI Agents SDK 都在简化单 Agent 开发流程。 Anthropic 官方的态度很明确：先从 Workflow 开始，人定义路径，解决80%的问题。Autonomous Agent 留给那20%真正需要的场景。 上下文工程正在成为新范式，但范式本身就是一个更高的门槛。 LangGraph 的状态管理、MCP 协议的上下文标准化都在推进，可方法论还不成熟，工具链还没成型，甚至“上下文工程”这个概念本身都没有统一定义。 这是方向，但不是捷径。 剩下的，短期无解。 多 Agent 协作的从众效应、角色不一致、臆想拼凑，这些根本性问题目前没有系统解决方案。 上下文膨胀，长任务中信息持续积累，压缩会丢关键细节，不压缩会撑爆窗口，同样没有完美方案。 Agent 行为合约还停留在学术论文里。工具生态的标准化，MCP 和 A2A 协议都还在早期，行业共识远未形成。 Khairallah 那篇教程的评论区里，有人说“收藏了，周末试”。如果你也是其中之一，这篇文章想说的是：试，但别焦虑。卡住不是你的问题，是这道题本身就还没被解出来。 但比“不用焦虑”更重要的是，下次你再看到“5分钟搭 AI 员工”的噱头，可以问自己三个问题：它有没有处理上下文崩塌？它有没有解决 Agent 协作的从众问题？它的工具调用有没有行为合约？ 三个都答不上来，那就是玩具。 5分钟搭的是玩具，不是员工。 能判断两者的区别，比假装不知道要好。 本文由 YouMind 自动从 Markdown 转换排版。

译搭AI Agent团队远非“5分钟教程”那么简单。环境配置（Python 3.10+等）劝退八成新手。Agent编排面临从众效应、角色不一致等缺陷，Anthropic采用Subagents模式，Cognition甚至发文称“不要构建多Agent”。上下文管理是最大隐性杀手，同一模型因上下文工程不同分差36个百分点。工具接入缺乏行为合约，API调用失败频发。低代码平台、单Agent SDK正降低门槛，但多Agent自由协作仍是难题。

elvis@omarsar0 · 6月19日51

// Automating SKILL.md Generation // Increasingly, mining sessions is one of the best ways to improve your agents. OpenAI released something similar yesterday that lets Codex package skills from interactions. (bookmark it) This paper explains a related approach. They run a three-stage pipeline that segments GUI trajectories, clusters them into candidate skills, and trains a skill-aware policy. The clusters are genuinely readable, with five of eight hitting 0.95 or higher purity against ground-truth workflow labels. But readability does not transfer. GRPO lifts skill-step accuracy only from 18.5% to 20.5%, leaves BrowseComp+ flat, and loses to trivial frequency priors. The authors name the three culprits: a weak boundary detector, an orderless segment representation, and an offline reward model. Paper: https://arxiv.org/abs/2606.20363 Learn to build effective AI agents in our academy: https://academy.dair.ai/

译关键要点：OpenAI昨日为Codex推出了从交互中打包技能的类似功能；论文提出三阶段流水线（GUI轨迹分割→聚类候选技能→训练技能感知策略）。聚类纯度优异（5/8簇达0.95以上），但可读性未迁移：GRPO仅将技能步骤准确率从18.5%提至20.5%，在BrowseComp+上无改善，甚至输给简单频率先验。作者指出三个缺陷：弱边界检测器、无序片段表示、离线奖励模型。

Rohan Paul@rohanpaul_ai · 6月19日44

This paper shows that a good generalist agent must remember hidden environment rules, not just observe the current state. That sounds obvious until you notice the trap this paper isolates: two worlds can show the agent the same state, offer the same goal, and still require opposite actions. At that moment, observation is no longer enough. The important object is not “memory” as a vague engineering feature, but memory as the place where hidden context must be carried when the environment refuses to label itself. The paper’s core idea is that memory is not optional in this setting, because a near-perfect agent must store enough past experience to tell which hidden environment it is currently in. The authors prove that when 2 hidden domains require incompatible actions at the same visible state, any agent that performs well across both domains must have different internal memory states for those domains. The big point is that good generalist agents do not just react to what they see now, because they must carry hidden context from earlier experience when the world can change underneath the same observation. ---- Link – arxiv. org/abs/2606.18746 Title: "What Must Generalist Agents Remember?"

译该论文指出，通用智能体不能仅依赖当前观测，必须记住隐藏环境规则。当两个隐藏域在相同可见状态下要求相反动作时，仅凭观察无法区分当前场景。作者证明，要在两个域都表现良好的智能体，必须为不同域维持不同的内部记忆状态。核心结论：好的通用智能体不是对当前所见做出反应，而是必须携带来自先前经验的隐藏上下文。

fofr@fofrAI · 6月19日19

When an agent says it's going to do something manually 👀

译当智能体说它要手动操作时 👀

Chubby♨️@kimmonismus · 6月19日47

Someone on Reddit built a WoW private server with 1,800 bots and AI chat via the DeepSeek API. Dead Internet Theory, but playable. An MMORPG with no real players, yet somehow it still feels human.

译某人在Reddit上搭建了一个WoW私服，包含1800个机器人，并通过DeepSeek API实现AI聊天。 死互联网理论，但可玩。 一个没有真实玩家的MMORPG，却不知何故仍然感觉像人类。

fofr@fofrAI · 6月19日55

How to make a team of co-ordinated AI agents: - set up your first preferred agent (it's your orchestrator) - ask it to configure Gemini Managed Agents or something like modal cpu instances to spin up sub agents in their own environment - kick off a deep research task to investigate best practices for managing a team of agents: best roles and skills for those roles, as well as managing the team and cross-communication and planning - have the agents apply best recommendations from the research - repeat this process in a loop (with increasing agent numbers if needed) With your team: - give them an empty repo, challenge them to make something, establish best practices, have agents observe problems, suggest fixes for agent management and rapidly iterate (this fleshes out race conditions, planning approaches, and so on)

译设置一个编排器智能体，由它配置Gemini Managed Agents或modal cpu实例，在独立环境中启动子智能体。先执行深度研究任务，探索管理智能体团队的最佳实践（角色、技能、跨通信与规划），再将最佳推荐应用于各智能体。重复该循环（可逐步增加智能体数量）。之后给团队一个空代码仓库，挑战其构建产品、建立最佳实践，让智能体观察问题、提出修复建议并快速迭代，从而暴露竞争条件、完善规划方法。

AYi@AYi_AInotes · 6月19日70

以后教AI干活居然不用写长prompt了，Codex刚更的新功能，你手动走一遍流程，它自动整理成可复用的skill，这个官方视频手把手教你怎么操作，中英文字幕帮大家做好了！ 我们大部分人用AI最大的痛点就是：你描述不清楚你要什么？像报销单怎么填、视频发布前加哪几个标签、周报从哪个系统扒数据，这些流程你闭着眼都能做，但如果让你写成 prompt，怎么也说不明白。 Codex 新上的 Record & Replay，换了个解法： 说不清？你做一遍给它看。 macOS 上手动走一遍流程，它安静的记录每一步， 录完自动整理成可检查、可复用的 skill， 下次直接跑，只换参数——文件名改一下、日期范围调一下、议题内容换一批，剩下的它都能按既定规则走完。 以前教 AI 靠写长 prompt，以后靠亲手演示一遍，这才是 Agent 走进日常工作的正确姿势啊， 目前 macOS 可用，需开 Computer Use 权限，具体操作指引见评论区↓

译Codex 上线 Record & Replay 新功能，解决用户写长 prompt 描述不清流程的痛点。用户在 macOS 上手动完成一次操作（如填写报销单、添加视频标签），AI 静默记录每一步，自动整理成可检查、可复用的 skill。下次执行时只需更换参数（如文件名、日期范围），其余步骤按既定规则自动完成。目前仅 macOS 可用，需开启 Computer Use 权限，详细指引见评论区。

小互@xiaohu · 6月19日63

牛P了 Codex推出一个 Record & Replay功能 也就是你可以教Codex干活 你把你在电脑上经常操作的人物给它演示一遍 Codex 会观察学习你的整个操作过程，然后自动生成一个 Skill 技能... 下次遇到同样的任务，Codex 就能按照你教它的流程和操作替直接替你干活... 官方拿"发 YouTube 视频"来演示： 他手动走一遍全套流程，拉元数据、配缩略图和英文字幕、上传存成私密、逐项核对。Codex 就在旁边看着，看完把整套流程记成了一个可复用的技能。 然后他新开一个对话，挂上下一条视频，Codex 自己照着全做完了，一步没差。 而且不只是发视频，你平时那些重复的电脑活都行: • 每个月报销，贴发票、填那张固定的单子 • 把一堆乱命名的文件批量重命名、归档 • 每周把数据导出来，填进固定的周报表 • 网上订票订酒店，重复填一遍又一遍的信息 干活的时候它自己调电脑操作、浏览器、你连的那些插件，组合着把事办完。 你不用再教 AI 每一步怎么做，只要做给它看一次,下次它就替你做... 从"每次写提示词"到"演示一次就够"，这是一个跨越...

译Codex 推出 Record & Replay 功能，用户可在电脑上演示一次操作流程，Codex 观察并自动生成可复用的 Skill。下次遇到同类任务，Codex 即可自动执行。官方以“发 YouTube 视频”演示：手动走完拉元数据、配缩略图和字幕、上传存为私密、核对等流程，新对话中 Codex 自动完成无差错。该功能适用于报销贴票、文件批量重命名归档、每周数据填报表、网上订票等重复性电脑操作，实现从“每次写提示词”到“演示一次就够”的跨越。

AYi@AYi_AInotes · 6月19日76

这可能是我近期看到的最值得深入研究的一次skills开源和工程脚手架，最后总结的5个工程思路大家可以直接拿去用。 DeepSeek 研究员 Deli Chen 把他的 AutoResearch 协议开源了，同时扔出一篇关于 Self-play 的综述（第四篇）。 最炸的地方是，他的代理第一次完全 autonomously 在 285B 模型上跑通了完整的 RL 研究闭环——实验设计、写代码、提交 GPU 任务、debug、到出结论，全程零人工干预。 要知道写代码和跑通研究闭环是两件事，就像学会炒菜和开一家每天出品稳定的餐厅，差的不只是一道菜，还有整套后厨流程。 至于论文里的结论，我放在评论区。

译DeepSeek研究员Deli Chen将AutoResearch协议开源，并发布Self-play综述论文。其AI智能体首次完全自主地在DeepSeek 285B模型上完成完整RL研究闭环——从实验设计、写代码、提交GPU任务、debug到结论总结，全程零人工干预。系统调用了GRPO工具，被视为持续学习研究的开端。

Z.ai@Zai_org · 6月19日54

Long-horizon is more than a concept. It should live in real-world scenarios, empowering AI builders to solve the problems that matter. And more scenarios are on the way.

译智谱 GLM-5.2 在内部 35 项挑战性移动开发任务（共 70 次试验）中完成率达 48/70，较 GLM-5.1 的 21/70 提升超两倍；同期 Claude Fable 5 为 56/70。主推文指出长程能力应落地真实场景，更多场景即将推出。

Berryxia.AI@berryxia · 6月19日71

有人用Codex连续干了38小时、提交301个分支，把自己的“创建skill的skill”升级到了2.0版本。 兄弟们，免费🆓开源直接用啊！ 姚金刚老师把元Skill（yao-meta-skill）做了重构和2.0升级，现在已经完成并推送到GitHub。 Codex在整个过程中持续拆解任务、提交分支、修复问题、迭代优化，最后产出了完整的升级方案和2.0与1.0的详细对比报告。 这个元Skill本身就是用来创建其他skill的工具，现在它自己先升级了一版。 升级后的版本在结构、可靠性和可扩展性上都有明显提升，而且所有文档和对比都公开了，别人可以直接参考怎么用agent做复杂工程重构。 最有意思的是整个升级过程本身就是一个活生生的例子：用高级agent（Codex）来重构“创建agent工具”的元框架。 这说明agent的能力已经强到可以自己参与到“如何更好地使用agent”的迭代里了。 地址见评论区👇

译姚金刚使用高级agent Codex连续38小时、提交301个分支，将自己创建其他skill的元Skill（yao-meta-skill）重构并升级至2.0版本，已推送到GitHub。Codex持续拆解任务、修复问题，产出完整升级方案与1.0→2.0对比报告。新版本在结构、可靠性和可扩展性上明显提升，所有文档公开。此次升级本身成为典型案例：高级agent已能参与“如何更好地使用agent”的框架迭代。

ginobefun@hongming731 · 6月19日48

http://x.com/i/article/2067749290982936576 # BestBlogs 早报 · 06-19｜Codex 录制回放工作流、Claude Code 会话变 Artifacts 页面、A2A 协议满周岁 在线阅读本期早报 ## 导语 Agent 学习方式正在从"写提示词"转向"看一遍就会"：OpenAI 让 Codex 通过一次录屏掌握完整工作流，Claude Code 把会话过程实时变成可分享的 Artifacts 页面，Google 的 A2A 协议则在满周岁之际，展示智能体之间如何安全地互相托付任务而不互相干扰。三条主线看似各自独立，其实都在回答同一个问题：当任务交给一个智能体之后，人到底还要插手多少。今天的精选还覆盖世界模型路线之争、CI/CD 渐进式交付方法论，以及开源模型的智能体化评测——这些内容共同构成了今天值得关注的全景。 ## 精讲一：OpenAI Codex Record & Replay：演示一次，即可复用浏览器工作流 OpenAI 给 Codex 上线了一项名为 Record & Replay 的新能力，核心思路很直接：与其写一段详尽到每一步的提示词，用户只需要在屏幕上把任务完整做一遍，Codex 就能把这次演示转化成一项可复用的自主技能。这把"教会 Agent 干活"的方式从语言描述换成了行为示范，对很多难以用文字讲清楚的操作流程来说，这是一个更自然的教学方式。 OpenAI 选择了一个很有代表性的日常任务来演示这项能力：把视频发布到 YouTube。这件事通常包含好几个重复性步骤——从内部发布表格里取出视频元数据，找到匹配的素材文件，再手动在 YouTube Studio 里逐项填写字段和设置。演示过程中，Codex 全程观察用户如何取出标题和描述、添加缩略图、加入英文字幕，并把视频配置保存为私密状态。录制完成后，Codex 并不是简单地把这段操作录像存下来，而是分析整个会话，提炼出一项定制技能：它会记录数据存放的位置、上传素材的组织方式，以及如何核验一切是否被正确保存。 真正体现这项能力价值的是后续的自主执行环节。当一个新任务被打开、一份新的视频素材包被附加进来时，Codex 完全接管整个流程：自动把素材包匹配到正确的表格行，填好元数据，上传缩略图和字幕，并安全保存视频——人不需要再插手任何一步。这种工作流自动化也不局限于视频平台。Codex 可以通过电脑操作、浏览器操作和已连接插件三种方式，把 Record & Replay 应用到各种数字环境里，潜在场景从格式化和分享代码仓库的 Pull Request，到按个人偏好配置日历邀约，覆盖范围相当广。 这种设计背后的逻辑值得多说一句：传统的提示词工程要求用户提前把流程的每一个分支、每一处异常都想清楚并写进指令里，而 Record & Replay 把这个负担转移给了模型本身——人只需要做一次正确的事情，剩下的"怎么把这件事讲清楚"交给 Codex 在事后分析里完成。这对那些步骤繁琐、依赖大量上下文（比如哪个文件夹放哪类素材、哪个按钮在哪个菜单里）却很难用语言准确描述的工作流来说，是一种更贴近人类教学习惯的方式，也更容易规模化复制到团队里的其他成员身上。 把这条新闻放在今天三条精讲的脉络里看会更清楚：Codex 解决的是"怎么把一次人类示范变成可复用的自主技能"，而精讲二里 Claude Code 的 Artifacts 解决的是"怎么把一次 Agent 会话变成团队可共享的可视化产物"——两者都在试图减少人在 Agent 工作之后还要做的解释和重复劳动。如果你对浏览器自动化和 Agent 技能沉淀感兴趣，这条值得通读，尤其是关于 Codex 如何从录制中提炼技能细节的部分。详见：OpenAI Codex Record & Replay：演示一次，即可复用浏览器工作流。 ## 精讲二：Claude Code 现已支持 Artifacts 渲染功能 Claude Code 上线了 Artifacts 功能：从今天起，一次会话过程中的工作进展能够被实时捕捉成一个可分享的可视化页面——PR 走查、系统说明文档、可筛选排序的仪表盘、甚至会随工作推进自动勾选完成项的发布清单，都能以这种形式呈现。一次 Claude Code 会话可能跨越排查故障、重构服务、分析数月数据等各种类型的工作，Artifacts 的价值在于把这些工作直接翻译成一个任何人都能打开浏览的网页，团队因此能把更多时间花在真正推进工作上，而不是反复沟通进展。 这项功能的关键设计是完全基于会话已有的上下文构建，不需要额外搭建数据源或基础设施。一个事故排查页面可以同时汇总代码里失败的测试和背后的函数、连接的监控工具里的错误突增曲线，以及刚刚那次会话里得出的根因推理——你只需要开口要一个页面，Claude Code 就会用已经存在的信息把它搭建出来。更重要的是这些页面是"活"的：当 Claude Code 更新一个 Artifact 时，已经打开的页面会原地刷新，团队成员在发布的瞬间就能看到更新；每次发布都是同一个链接下的新版本，带版本历史可以随时回溯，还有一个画廊页面方便浏览和管理所有已创建的 Artifacts。 从 Anthropic 内部测试来看，调试是最常见的使用场景之一：一名工程师在站会前开始排查一个事故，Claude Code 处理日志并发布一个 Artifact——时间线、可疑提交记录、错误率曲线一应俱全，她把链接从页面头部分享给团队；等站会开始时，Claude 已经随着排查进展把这个页面重新发布了两次。有了 Artifacts，团队成员和相关方不再需要"听 Agent 讲一遍发现了什么"，因为所有人看到的是同一个、带着相同上下文的视图。每个 Artifact 默认仅作者本人可见，准备好后可以直接从页面分享给团队或整个组织；管理员可以用组织级开关和基于角色的权限管理访问，设置留存策略，并通过合规 API 获得组织范围的可见性。目前这项功能处于 Beta 阶段，面向 Team 和 Enterprise 组织开放。 这条新闻和精讲一放在一起看会有意思的呼应：Codex 的 Record & Replay 让 Agent 学会一项可重复执行的技能，而 Claude Code 的 Artifacts 让 Agent 已经做完的工作变得可见、可分享、可持续更新——前者解决"怎么教"，后者解决"怎么呈现"，两者合在一起，正在慢慢补全"人和 Agent 协作"这件事里原本依赖大量手动沟通的环节。如果你正在评估团队协作场景里怎么用好 Agent 产出的中间结果，这条值得细读各角色的使用范例部分。详见：Claude Code 现已支持 Artifacts 渲染功能。 ## 精讲三：A2A 如何构建一个协作智能体的世界 Google 的智能体协作协议 A2A（Agent-to-Agent）今天正好满一周岁。文章的核心论点是：如果把智能体当作普通 API 来调用，会严重限制它的潜力。API 是刚性且确定性的，调用它要么返回数据要么失败；而智能体是流动且自主的——当一个智能体调用 A2A 的另一个智能体时，发起的其实是一场协作，接收方能够理解意图、完善方案、对不完整的请求提出异议，并在情况不对时主动追问。这是 A2A 与传统 REST API 最根本的区别。 A2A 带来的架构优势集中在几个方面。其一是"安全边界"：企业场景里，智能体经常需要调用敏感数据或自研的内部流程，这些内容不能暴露给公开的大模型或第三方系统，A2A 支持把任务交给一个专门的内部智能体、由它在自己的安全环境里完成处理，请求方只拿到高价值的输出结果，专有数据和"怎么做"的逻辑始终被封装、严格保密。其二是"零上下文污染"：大模型的上下文窗口是有限的，如果强迫一个主智能体去处理复杂的多步骤依赖，它的上下文窗口会被迅速填满，导致幻觉和性能下降；通过 A2A，专精的同行智能体可以自己处理庞大的依赖关系和内部状态，不会占用主智能体的"内存"。其三是工作负载的分布式协作：不同部分的方案可以由不同的同事、团队、供应商或托管智能体服务分别构建和维护，这让整体应用设计更简单，长期维护也更容易。 文章用蛋白质结构预测工具 FoldRun 具体展示了这套架构的运作方式。预测蛋白质的三维结构是生物学里的"圣杯"级难题，但对开发者来说几乎是一场基础设施噩梦：海量遗传数据库、专用 GPU 需求，再加上 AlphaFold、OpenFold、Boltz 等模型各自的多步骤生命周期管理，从零搭建这套能力是一道极高的"复杂度陡坡"。在 A2A 的世界里，开发者不需要拼接脆弱的 API 工作流，也不需要自建智能体、注入专门技能、加固安全环境——只需要把 FoldRun 这个独立的智能体节点接入 Gemini Enterprise、Gemini CLI 或任何兼容 A2A 的环境，用自然语言把任务交给它，FoldRun 会根据预测置信度自主调整参数、在 AlphaFold 2、OpenFold 3 或 Boltz-2 之间做出选择，并把结果作为一个专精同行的产出交付回来。生物科技公司 BicycleTx 作为核心设计合作伙伴，反馈这种智能体接口方式让团队跨部门测试和集成工作流变得容易了很多。 目前 A2A 的 Python 和 Go SDK 已经达到 1.0 正式版，Java（Beta）和 .NET（Preview）也在向 1.0 规范靠拢，JavaScript/TypeScript 则停留在稳定的 v0.3 线上、正在推进 1.0 工作。应用场景正在从科研扩展到智能体商务与自主支付（让智能体安全地协商交易、核验库存、执行 B2B 采购）、企业数据与实时流处理（专精的 A2A 智能体守在数据边缘，只在满足特定合规条件时才拉取洞察并触发下游工作流）、跨平台 IT 与运维协同（一个 HR 智能体可以安全地把角色参数交给一个专门的 DevOps 智能体，由后者跨多个互不相通的 SaaS 平台自主开通软件许可、仓库权限和安全环境），以及要求量子安全端到端消息层加密的受监管电信网络。把这条新闻和前两条精讲连起来看：Codex 教会 Agent 复用一项技能、Claude Code 让 Agent 的工作过程变得可见，而 A2A 则让不同的 Agent 能够彼此托付任务、安全协作——三者拼在一起，正好是"单个 Agent 能力"到"多 Agent 协作生态"的一条完整链路。如果你关心企业级 Agent 架构怎么落地，这条值得细读 FoldRun 案例和四个应用场景部分。详见：A2A 如何构建一个协作智能体的世界。 ## 速览 哪条路线，才能通往「世界模型」的终局？｜对话黄碧薇：Aether AI 创始人。Aether AI 创始人黄碧薇教授深度拆解了世界模型领域被过度使用的概念边界：视频生成、3D 生成、JEPA、VLA、WAM 似乎都能被叫作世界模型，但她提出了一条很少被提及的"第四条路线"——以因果 AI 为核心的因果世界模型。访谈里她解释了真正的世界模型需要在隐空间里同时学会哪三样东西，为什么 LLM 不需要理解因果也能逻辑严密，而世界模型却绕不开因果；也谈到了 VLA 的能力天花板、WAM 为什么可能只是一个中间态，以及她从 UCSD 教授转型创业者的心路历程。这期节目对关注具身智能和下一代 AI 范式的读者会很有启发。详见：哪条路线，才能通往「世界模型」的终局？｜对话黄碧薇：Aether AI 创始人。 你的 Harness 工作流真的在进步吗？我们用一场考试撕掉了遮羞布。文章提出了一个尖锐的问题：团队精心调教的 Harness 研发工作流，到底是在进步还是退步，很多团队其实回答不了，只能靠"主观 vibes"判断。作者团队设计了一套"出题—答题—改卷"的考试机制，把可重复、可归因、闭环作为三个不可妥协的设计原则，用多维度打分、证据和改进建议取代简单的二值判定，试图把 Harness 工作流的演进从感觉驱动变成数据驱动。这是一篇罕见的系统化阐述 Agent 工作流评测方法论的工程文章。详见：你的 Harness 工作流真的在进步吗？我们用一场考试撕掉了遮羞布。 超越流水线的 CI/CD：Robert Erez 谈渐进式交付、GitOps 与前滚恢复。Robert Erez 把 CI/CD 从一份流水线检查清单，重新定义成一套务实的风险管理方法论。他把持续集成、持续交付、持续部署拆解成一条成熟度路径，并指出渐进式交付（金丝雀发布、蓝绿部署、功能开关）的核心价值是缩小变更的影响半径；同时强调功能开关本身会产生技术债——需要明确的负责人、过期时间和清理流程。文章还谈到 GitOps 应该被理解为一组特性，而不是"必须把一切都存进 Git"的硬性要求。对正在打磨发布流程的工程团队，这是一份很实用的方法论梳理。详见：超越流水线的 CI/CD：Robert Erez 谈渐进式交付、GitOps 与前滚恢复。 从开源到 Agent，从组织到个体：AIEC 大会现场侧记。两位资深行业观察者在清华大学全球产业研究院主办的人工智能+生态大会（AIEC 2026）现场，深度复盘了 AI 领域当下的核心共识与非共识：企业 AI 转型中组织和人的权重在提升、Agent 正在成为"数字员工"、产品形态趋同之后差异化到底在哪里，以及模型公司是否会通吃应用层。对谈也延伸到开源生态的最新表态，以及技术洪流之下个体的判断力、品味与表达欲为什么反而变得更重要。适合关心行业格局变化和个体定位的读者。详见：从开源到 Agent，从组织到个体：AIEC 大会现场侧记。 MosaicLeaks：你的研究智能体还能保守秘密吗？。深度研究智能体越来越多地把私有本地文档和外部工具（如网页检索）结合使用，这带来一个容易被忽视的隐私风险：智能体对外发出的查询本身就可能泄露敏感信息。文章提出的 MosaicLeaks 基准测试发现，多个被测模型都存在频繁的隐私泄露，而且只针对任务表现做训练反而会让泄露问题更严重；研究团队进而提出了一种隐私感知的强化学习训练方法 PA-DR，能把严格链路成功率从 48.7% 提升到 58.7%，同时把答案/完整信息泄露率从 34.0% 降到 9.9%。这是一篇对正在构建深度研究类 Agent 的团队很有参考价值的安全研究。详见：MosaicLeaks：你的研究智能体还能保守秘密吗？。 智能体化程度够了吗？用自有工具对开源模型进行基准测试。文章提出了一种新的基准测试思路：不只衡量智能体是否完成了任务，还要衡量它为完成任务付出了多少工作量——花了多少时间、消耗了多少 token。作者团队以 transformers 库为案例，发现引入新的 CLI 和 Skill 之后，大型开源模型完成任务的效率明显提升，但同样的改动反而会损害小型模型的表现，揭示出"为 Agent 优化软件"这件事并不是对所有模型一视同仁。对正在做工具或库的智能体友好化改造的团队，这篇提供了一套可操作的衡量框架。详见：智能体化程度够了吗？用自有工具对开源模型进行基准测试。 TPU 上的 MoE 推理优化：SGLang-JAX 用 Pallas 内核砍延迟 53%。文章详细介绍了在 TPU v7x 上为 Ling-2.6-1T 这个 MoE 模型做推理优化的过程，核心是一个名为 Fused MoE V2 的全新 Pallas 内核，它把数据移动巧妙地隐藏在计算背后，让 MoE 预填充延迟从 5.16 毫秒降到 2.42 毫秒，降幅达 53%；在解码吞吐量上，16 块 TPU v7x 芯片相比 16 块 H200 GPU 最高能达到 1.77 倍。对关注大模型推理硬件优化和 MoE 架构工程细节的读者，这是一篇值得细读的硬核技术文章。详见：TPU 上的 MoE 推理优化：SGLang-JAX 用 Pallas 内核砍延迟 53%。 ## 补充阅读 为 Cloudflare 带来更多 Agent 框架，从 Flue 开始——Cloudflare 推出 Agents SDK 作为生产级 Agent 框架的平台层，并介绍了基于该 SDK 构建的开源框架 Flue，用来解决持久化执行、安全代码执行和持久化文件系统等生产环境里的常见挑战。适合关注 Agent 基础设施和框架选型的读者。详见：为 Cloudflare 带来更多 Agent 框架，从 Flue 开始。 3 亿美元 ARR、估值超 20 亿美元，演语科技是怎么做 ToC 应用增长的？——深度复盘演语科技（LiblibAI、LibTV）如何聚焦专业内容创作者、做厚应用层工作流、激进借力模型迭代，在 AI 应用层普遍承受质疑的当下实现 3 亿美元 ARR 和超 20 亿美元估值。适合关心 AI 应用商业化路径的读者。详见：3 亿美元 ARR、估值超 20 亿美元，演语科技是怎么做 ToC 应用增长的？。 Spring Security 7 新特性：可组合 MFA、更安全的 OAuth 2、模块化配置与 MCP 安全——现场演示展示了 Spring Security 7 如何把认证因素转化为可组合的授权数据，并提升配置安全性、OAuth 2 默认机制、受保护 HTTP 客户端，还加入了实验性的 MCP 安全能力。适合 Java/Spring 生态的后端开发者。详见：Spring Security 7 新特性：可组合 MFA、更安全的 OAuth 2、模块化配置与 MCP 安全。 生产级 AI 实战手册：如何在企业规模部署可衡量、可追责的智能体——提出一套经过企业实践检验的方法论：团队应该先建立与业务目标挂钩的评估、追踪、数据治理、编排和事故责任机制，再去选择模型或发布智能体，而不是反过来。适合负责企业级 AI 落地的工程和产品负责人。详见：生产级 AI 实战手册：如何在企业规模部署可衡量、可追责的智能体。 如何选择创业点子：先坚定投入，再用客户洞察找到真正的机会——YC 合伙人 John 认为，创始人不应该继续寻找完美的创业点子，而应该选定一个有潜力的方向坚定投入，通过深入理解客户和快速执行去判断它是否可行。适合正在纠结方向选择的早期创业者。详见：如何选择创业点子：先坚定投入，再用客户洞察找到真正的机会。 驾驭 Claude Code：技能、钩子、子智能体等——来自 Claude 博客的技术指南，系统梳理了七种自定义 Claude Code 行为的方法，并给出了在什么场景该用哪种方法的决策框架。适合正在搭建复杂 Claude Code 工作流的开发者，也可以和今天精讲二里的 Artifacts 功能对照着读。详见：驾驭 Claude Code：技能、钩子、子智能体等。 利用 AI 帮助医生诊断影响儿童的罕见遗传疾病——一项发表在《NEJM AI》上的研究显示，使用 OpenAI 推理模型重新分析 376 个此前未解决的罕见病病例后，医生在其中 18 个病例里找到了诊断线索，额外诊断率达到 4.8%。适合关心 AI 在医疗诊断领域具体落地效果的读者。详见：利用 AI 帮助医生诊断影响儿童的罕见遗传疾病。 ## 今日阅读路径 如果今天时间有限，建议按这个顺序读：第一，精讲一的 OpenAI Codex Record & Replay，了解 Agent 怎么从一次人类演示中学会一项可复用技能，重点看从录制到自主执行的转变；第二，精讲二的 Claude Code Artifacts，理解 Agent 完成的工作怎么变成团队可共享的实时页面，重点看调试场景里的具体使用范例；第三，精讲三的 A2A 协议满周岁，看看不同 Agent 之间怎么安全地互相托付任务，重点看 FoldRun 案例和"安全边界、零上下文污染"两个架构优势。三篇连起来读，正好串出今天"单个 Agent 学习能力—工作过程可见性—多 Agent 协作生态"这条主线。 如果还有余力，再补两篇：一篇是黄碧薇教授关于世界模型"第四条路线"的访谈，从具身智能的角度补上今天 Agent 主线之外的另一个技术前沿；另一篇是腾讯技术工程的 Harness 工作流评测体系，从工程落地的角度看一个真实团队是怎么把"Agent 工作流到底有没有变好"这个问题量化下来的。这五篇加在一起，基本能拼出今天 AI 行业从 Agent 能力进化、协作架构到落地评测方法的完整链路。 BestBlogs 是 AI 驱动的私人阅读助手，帮助你建立稳定、可信、个性化的高质量信息输入。它帮你判断什么值得读、协助你读懂，并逐渐理解你关注什么，欢迎体验。

译OpenAI Codex 上线 Record & Replay，通过录屏演示一次操作（如发布 YouTube 视频），自动提炼为可复用的浏览器工作流。Claude Code 新增 Artifacts 功能，会话进展实时生成可分享的可视化页面（如事故排查面板），支持版本历史和实时刷新，Beta 期面向 Team/Enterprise。Google A2A 智能体协作协议满一周年，强调安全边界、零上下文污染和分布式架构，Python/Go SDK 达 1.0 正式版。

ginobefun@hongming731 · 6月19日40

BestBlogs 早报 · 06-19 # OpenAI Codex / Claude Code Artifacts / A2A 协议 / Record & Replay / FoldRun [1] ★ 精讲｜OpenAI Codex Record & Replay：演示一次，即可复用浏览器工作流 [视频] OpenAI 为 Codex 上线 Record & Replay：用户只需演示一次完整操作（如在 YouTube Studio 填写元数据、上传缩略图、保存私密视频），Codex 就能把这次录制转化为可复用技能，在新任务里自主匹配素材、填写信息、核验结果。能力覆盖电脑操作、浏览器操作和已连接插件，未来还能扩展到整理 PR、安排日程等场景——把「写提示词」换成了「做一次示范」。 来源：OpenAI https://www.bestblogs.dev/video/cb0632f [2] ★ 精讲｜Claude Code 现已支持 Artifacts 渲染功能 Claude Code 上线 Artifacts 功能：会话过程能被实时转化成可分享的可视化页面——PR 走查、系统说明、仪表盘、发布清单等，且随工作推进自动更新同一链接。基于会话上下文（代码库、连接器、对话本身）直接生成，无需额外搭建数据源。团队调试场景验证最多：工程师把故障排查过程发布成时间线、可疑提交和错误曲线，站会前已迭代两次，所有人对齐同一视图。目前 Beta 阶段面向 Team/Enterprise 组织开放。 来源：Claude Blog https://www.bestblogs.dev/article/71cae674 [3] ★ 精讲｜A2A 如何构建一个协作智能体的世界 Google 的智能体协作协议 A2A 满周岁：相比把智能体当 API 调用，A2A 让智能体之间发起真正的协作——保护内部「秘方」逻辑不外泄、避免单一智能体上下文被海量依赖污染、支持智能体反馈不完整请求并追问。文章以蛋白质结构预测工具 FoldRun 为例：开发者只需把任务交给 FoldRun 这个独立智能体节点，无需自建 GPU 流水线和模型生命周期管理。A2A 的 Python/Go SDK 已 1.0 GA，正拓展到电商支付、企业数据流和跨平台运维场景。 来源：Google Developers Blog https://www.bestblogs.dev/article/b9c75cf5 [4] 哪条路线，才能通往「世界模型」的终局？｜对话黄碧薇：Aether AI 创始人 [播客] 黄碧薇教授深度拆解世界模型的技术现状，提出以因果 AI 为核心的第四条路线，分享了因果世界模型如何让机器人真正理解物理规律并实现举一反三，以及她从学者到创业者的心路历程。 来源：十字路口 Crossing https://www.bestblogs.dev/podcast/62e0e8d [5] 你的 Harness 工作流真的在进步吗？我们用一场考试撕掉了遮羞布 本文提出一套面向 Harness 工作流的可量化、可回归、闭环的评测体系，通过「出题-答题-改卷」的考试机制，解决工作流效果无法客观评估的问题。 来源：腾讯技术工程 https://www.bestblogs.dev/article/0e07faec [6] 超越流水线的 CI/CD：Robert Erez 谈渐进式交付、GitOps 与前滚恢复 [视频] Robert Erez 将 CI/CD 从流水线检查清单提升为一套务实的风险管理方法，其核心包括渐进式交付、实用主义 GitOps、前滚恢复以及规范的功能开关治理。 来源：The Pragmatic Engineer https://www.bestblogs.dev/video/095dc0a [7] 从开源到 Agent，从组织到个体：AIEC 大会现场侧记 [播客] 两位资深行业观察者在 AIEC 大会现场，深度复盘了 AI 领域从模型、Agent 到组织变革的核心共识与非共识，并探讨了技术洪流下个体的价值与定位。 来源：屠龙之术 https://www.bestblogs.dev/podcast/2784813 [8] MosaicLeaks：你的研究智能体还能保守秘密吗？ MosaicLeaks 引入了一个基准测试和一种隐私感知的强化学习方法（PA-DR），表明深度研究智能体会通过网页查询中的马赛克效应泄露隐私信息，并且仅针对任务性能进行训练会使泄露问题更加严重。 来源：Hugging Face - Blog https://www.bestblogs.dev/article/67ee7e6d [9] 智能体化程度够了吗？用自有工具对开源模型进行基准测试 本文介绍了一种基准测试框架，它不仅衡量智能体是否成功完成任务，还衡量其付出的工作量，并以 `transformers` 库为例，展示了新的 CLI 和 Skill 能帮助大型开源模型，但会损害小型模型。 来源：Hugging Face - Blog https://www.bestblogs.dev/article/b50a486d [10] TPU 上的 MoE 推理优化：SGLang-JAX 用 Pallas 内核砍延迟 53% 本文详细介绍了在 TPU v7x 上优化服务 Ling-2.6-1T MoE 模型的过程，重点是一种新颖的 Pallas 内核（Fused MoE V2），它将数据移动隐藏在计算之后，实现了 MoE 预填充延迟降低 53%，并在解码吞吐量上最高达到 H200 GPU 的 1.77 倍。 来源：LMSYS Blog https://www.bestblogs.dev/article/8efc1b4e --- http://BestBlogs.dev · 发现真正适合你的高质量内容 BestBlogs 是 AI 驱动的私人阅读助手，帮助你建立稳定、可信、个性化的高质量信息输入。 关注你感兴趣的来源和主题，每天生成一份更适合自己的「我的早报」。 在线阅读：https://www.bestblogs.dev/explore/brief/2026-06-19

译OpenAI为Codex上线Record & Replay，演示一次完整操作即可复用浏览器工作流；Claude Code支持Artifacts渲染，会话实时生成可视化页面并自动更新，Beta面向Team/Enterprise组织；Google A2A协议满周岁，Python/Go SDK已达1.0 GA，以FoldRun为例展示智能体协作。其他动态：MosaicLeaks基准测试揭示深度研究智能体隐私泄露风险；SGLang-JAX在TPU v7x上优化Ling-2.6-1T MoE模型，延迟降低53%。

Rohan Paul@rohanpaul_ai · 6月19日75

Viktor grew a $20M annualized revenue run rate outside Microsoft Teams. Now it works inside Teams. This revenue is from an AI employee that does the job, not one that just replies. Try free at @viktor__com . $100 in credits, no card.

译AI 员工 Viktor 在 Slack 上实现 2000 万美元年化收入（无销售团队、未大规模推广），现已正式进驻 Microsoft Teams。Viktor 定位为零门槛 AI：用户无需学习、无需提示词，像 @同事 一样提及即可获得完整工作成果，甚至无需主动 @ 也能自动完成。产品面向 Teams 的 3.2 亿用户，助力企业内部运营和管理人员零学习成本使用 AI。即日起免费试用，含 100 美元信用额度，无需绑定信用卡。

Ethan Mollick@emollick · 6月19日67

I have given AA a hard time about its previous agentic evaluation but this looks like a good and impressive benchmark for real world knowledge work that is unsaturated and had private hold out tests. This is one to watch - I didn’t see a human comparison score though?

译Ethan Mollick 称赞 AA-Briefcase 是真实知识工作的优质基准，未饱和且含私有保留测试，同时询问是否有与人类的对比。该基准由 @ArtificialAnlys 发布，测试模型在多周、多任务项目中的能力，输入含数万条 Slack 消息和数千封邮件。模型排名：Claude Fable 5（已不可用）以 1587 Elo 居首，Claude Opus 4.8（1356）第二，GLM-5.2 max（1266）第三。结果凸显难度：最佳模型仅 3% 任务满足全部标准，31/91 任务无模型超过 50%，成本跨度约 800 倍。

Chubby♨️@kimmonismus · 6月19日69

I'm curious to see if agents like Viktor will increase the enjoyment of Microsoft Teams meetings ;)

译团队协作AI智能体Viktor正式登陆Microsoft Teams。此前已在Slack上线，仅靠单一应用实现2000万美元年化收入运行率（无销售团队、无推广）。Viktor主打零门槛：用户无需学习、无需提示，像@同事一样提及Viktor即可完成任务，甚至无需主动提及，价值自动送达。面向全球3.2亿Microsoft Teams用户，面向大公司一线运营与管理者。新用户获赠100美元启动积分，无需绑定信用卡。

Berryxia.AI@berryxia · 6月19日66

这货Browser Use又整活了，兄弟们！ 这下真的是给你的“Agent 长眼睛了！” 开源还免费🆓 它直接开源了个浏览器agent模板B，让任何agent都能用上真实的云端浏览器，还能实时看到它在网页上操作。 这个模板叫B，基于Vercel的Eve构建。 给你的agent接上Browser Use Cloud browser后，它就能真正上网浏览、点击、填写表单，而且你能通过browser-harness实时看到整个过程。 GitHub上直接clone就能用，还支持初始化skills和MCPs。 以前做browser agent最麻烦的就是：要么用模拟环境看不见真实交互，要么黑箱运行出问题不知道哪里错了。 现在有了这个模板，agent在网页上的每一步都可视化、可调试，还能直接连真实云浏览器。 这其实把browser automation从“能用”推向了“真正好用”的阶段。 Agent不再是只在代码里模拟网页，现在能在真实网页环境里执行任务，还能被人类实时观察和干预。 最关键的是它开源了模板，任何人都能基于这个快速搭建自己的browser agent。 未来可能越来越多agent会默认带上一个“看得见”的浏览器，而不是纯文本交互。 现在开源的生态真好啊😆

译Browser Use 开源了基于 Vercel Eve 构建的浏览器 agent 模板 B。该模板让任意 agent 接入真实云端浏览器（Browser Use Cloud），实现网页浏览、点击、填表等操作，并通过 browser-harness 实时可视化执行过程，支持调试。模板已发布在 GitHub，可直接 clone 使用，支持初始化 skills 和 MCPs。开源免费，降低了开发可观测、可干预的 browser agent 的门槛。

Berryxia.AI@berryxia · 6月19日57

兄弟们，大厂们谁都不闲着啊！ 怎么一夜间，各大AI厂商都开始自动化！ Cursor现在可以让你用自然语言描述任务，它就自动帮你配置触发器、指令和工具，变成可运行的automation。 /automate 技能上线了：你直接说“我要自动处理GitHub issue”或者“收到Slack特定消息就执行这个流程”。 Cursor就会帮你搭好整个automation，包括触发条件、执行指令和所需工具。 目前已经支持Slack emoji触发（给消息点表情就启动）、GitHub issue/review/workflow触发，还加了cloud agents的computer use。 这把设置agent自动化从“手动写配置”变成了“说一句人话就行”。 以前你得自己搞trigger、写prompt、连工具，现在Cursor直接把这些脏活累活包了。你描述目标，它帮你生成可编辑的完整流程。 最有意思的是这正在把agent从“一次性聊天工具”往“长期运行的自动化系统”推。 有了自然语言配置+多种触发器，开发者可以快速把重复工作变成agent接管，而不需要成为自动化专家。 以前大家觉得建agent workflow门槛高，现在Cursor把这个门槛又往下砸了一层。 未来可能越来越多日常开发和团队协作流程，会从“人手动操作”变成“人描述一次、agent长期跑”。 感觉也是和codex 的一些功能有点相似呢～

译Cursor 推出 /automate 技能，开发者用自然语言描述任务即可自动配置触发器、指令和工具，生成可运行的 automation。支持 Slack emoji 触发、GitHub issue/review/workflow 触发，新增 cloud agents 的 computer use 能力。以前需手动配置，现在只需描述目标，Cursor 自动生成完整流程。该功能降低了 agent workflow 的搭建门槛，将 agent 从一次性聊天工具推向长期运行的自动化系统。

Artificial Analysis@ArtificialAnlys · 6月19日55

Announcing AA-Briefcase, the benchmark for the next era of agentic knowledge work AA-Briefcase is our new benchmark for testing models on long-horizon knowledge work tasks in complex projects built by industry experts. Models are evaluated on multi-week projects, each with many linked tasks and thousands of input source files. We evaluated Claude Fable 5 from @AnthropicAI before it became unavailable, and it currently leads with an Elo score of 1587, followed by Claude Opus 4.8 (max, 1356), Opus 4.7, and the recently-released GLM 5.2 (max, 1266) from @Zai_org. Claude Fable 5 cost $31 on average to run each AA-Briefcase task, followed by Claude Opus 4.8 at $10.40, GPT-5.5 (xhigh) at $3.68 and GLM-5.2 (max) at $2.40. AA-Briefcase comprises four private scenarios, each representing a multi-week knowledge work project set in a realistic organizational context. A public fifth scenario has been released via @huggingface as a representation of scenario structure, submission, and grading (AA-Briefcase Lite). This does not count toward official AA-Briefcase results, and is demonstrative only. Key elements of AA-Briefcase: ➤ Realistic long-horizon projects: AA-Briefcase moves beyond single, disconnected prompts by evaluating models across a coherent long-horizon project. Tasks build week by week, draw on shared institutional context, and require deliverables such as financial models, board presentations, and design mock-ups ➤ Large volumes of fragmented context: AA-Briefcase requires models to reason across thousands of inputs, including company documents, meeting transcripts, large-scale data exports, 25,000+ Slack messages and 3,500+ emails. These sources are fragmented, messy, and often contain realistic contradiction, testing whether models can navigate the ambiguity of real-world knowledge work ➤ Composite rubric and pairwise grading: AA-Briefcase combines binary rubric checks for ground-truth correctness with pairwise grading on analytical quality and presentation quality. Unlike many evaluations that focus on a single metric, AA-Briefcase tests agentic capabilities more comprehensively, exposing cases where models produce outputs that look polished but are incorrect or lack analytical rigor ➤ Built by industry experts: AA-Briefcase scenarios mirror real-world knowledge work, with tasks developed over months by experts across data science, product management and corporate strategy from companies including Google, McKinsey & Company and BCG. Task challenges are drawn from professional experience, making AA-Briefcase more reflective of the ambiguity, messy context and competing priorities that define real-world knowledge work Key results: ➤ Claude Fable 5 leads AA-Briefcase at 1587 Elo: This is followed by Claude Opus 4.8 (1356) with the next-best non-Anthropic model, GLM-5.2 (max), ~90 points back at 1266. Note that Claude Fable 5 did not use the Opus 4.8 fallback for any task in AA-Briefcase ➤ Cost per task varies by ~800x across models tested: Claude Fable 5 leads the benchmark but costs more than $31 per task on average, compared to ~$0.04 for DeepSeek V4 Flash (max). The strongest price/performance options are open weights models such as GLM-5.2 (max) and DeepSeek V4 Pro (max), with GLM-5.2 (max) scoring only ~90 Elo below Claude Opus 4.8 (max) for less than 25% of the cost ➤ Real-world complexity remains difficult for models: The top performer, Claude Fable 5, satisfies all rubric criteria on just 3% of AA-Briefcase tasks. On 31 of 91 tasks, no model scores above 50% on the rubric criteria ➤ Task difficulty scales with the number of required input files: For each rubric check, we identify the set of source files needed to pass. Across all models, pass rates fall as this file count increases, though top-tier models degrade less than weaker models More details below in thread ⬇️

译Artificial Analysis 推出新基准 AA-Briefcase，用于评估模型在长期知识工作项目中的智能体能力。基准包含 4 个私有场景（每项目需处理 25000+ Slack 消息、3500+ 邮件等碎片化上下文）及一个公开演示场景。评测结果：Claude Fable 5 以 Elo 1587 领先，其次为 Claude Opus 4.8（1356）、Opus 4.7 及智谱 GLM 5.2（max，1266）。成本方面，Claude Fable 5 平均每任务 $31，Opus 4.8 为 $10.40，GPT-5.5 (xhigh) 为 $3.68，GLM 5.2 (max) 为 $2.40，DeepSeek V4 Flash (max) 仅约 $0.04。所有模型中仅 3% 的任务满足全部标准，31/91 个任务无模型得分超 50%，显示真实世界复杂性仍是挑战。最佳性价比为开源权重模型 GLM-5.2 (max) 和 DeepSeek V4 Pro (max)。

🚨 AI News | TestingCatalog@testingcatalog · 6月19日65

OPENAI 🔥: Codex now has a new Record & Replay plugin that captures your actions and converts your workflow into an executable skill. My workflow 👀 * Not available in EEA, UK, and Switzerland yet

译OPENAI 🔥: Codex 现在有了一个新的 Record & Replay 插件，它可以捕获你的操作，并将你的工作流程转换为可执行的技能。 我的工作流程 👀 * 尚不可在 EEA、UK 和瑞士使用。

Berryxia.AI@berryxia · 6月19日70

Matthew Berman直接建了个Loop Library，把各种agent loop集中起来，找现成模板、提交自己的，一键就能用。 这个库专门收集可直接拿来用的agent循环流程，从简单的任务自动化到复杂的多步工作流。 想找现成的就去搜，想贡献自己的就直接提交。 背后还有http://here.now合作托管，目标就是让大家不用每次都从零设计loop。 以前做agent最费时间的就是设计循环结构：怎么退出、怎么验证、怎么处理失败。 现在有了社区库，这些“基础设施”被公开化了。 你可以直接拿别人验证过的loop改一改就用，或者把自己的经验贡献出去，让更多人少踩坑。 这其实在把agent开发从“每次都要重新发明轮子”往“搭积木”方向推。 Loop不是孤立的prompt，将其可复用、可迭代的工作单元。 把这些loop开源和社区化，相当于给agent生态建了一个公共的“流程市场”。 地址见评论区👇

译Matthew Berman推出Loop Library，一个专门收集可直接复用的agent循环流程的社区库。库中收录从简单任务自动化到复杂多步工作流的各种loop模板，开发者可直接搜索使用，也可提交自己的循环。该库由http://here.now合作托管，旨在解决agent开发中循环结构设计（退出、验证、失败处理）的重复劳动，推动agent开发从“每次重新发明轮子”转向“搭积木”模式。

Berryxia.AI@berryxia · 6月19日55

卧槽～ 这个功能有点实用啊！ 自动化工作流，不会写Skills？ 直接录屏有嘴就行了…… OpenAI Codex现在可以让你“演示一次”，就把重复任务变成可编辑的技能了。 Record & Replay功能上线了：你直接录制一次工作流（比如报销流程、请假申请），Codex就能把这个演示自动转成一个可检查、可编辑的skill。 以后再遇到同样任务，直接调用这个skill就行，不用每次都重新教。 你控制录制的开始和结束，Codex会把整个流程结构化成inspectable的技能，还能继续编辑优化。 目前仅支持macOS ，欧洲国家暂不支持，后面会支持。 这实际上是将“示范教学”直接转化为产品了。 以前做agent最烦的就是要把复杂流程写成prompt或者多步指令，现在直接录一遍，AI自己把动作序列和逻辑抽取出来。 技能还能被编辑，意味着你可以持续迭代，而不是一次性prompt写死。 以前大家觉得agent构建门槛高，是因为要写大量prompt和逻辑。 现在“录制一次”把这个门槛又往下拉了一层。 未来可能越来越多重复性工作，会从“手写流程”变成“演示给AI看”。 这波更新把Codex从“聊天式coding助手”往“可积累技能的agent平台”又推进了一步。

译OpenAI Codex 推出 Record & Replay 功能。用户录制一次工作流（如报销、请假），Codex 自动将其转化为可检查、可编辑的 skill（技能）。后续同类任务可直接调用该 skill，无需重复教学。用户控制录制起止，技能可继续编辑优化。目前仅支持 macOS，欧洲国家暂不支持。该功能将“示范教学”直接转化为可积累的 agent 技能，降低了从手写 prompt 到“演示即交付”的门槛。

elvis@omarsar0 · 6月19日64

Excited to share my new agent skill. /youtube-notetaker generates Artifacts from YT videos. Captures slides, notes, transcription, and whatever you want. Open-source, and you can customize it as you please.

译很高兴分享我的新AI智能体技能。 /youtube-notetaker 可从YouTube视频生成Artifacts。 捕获幻灯片、笔记、转录以及你想要的任何内容。 开源，你可以按需自定义。

Chubby♨️@kimmonismus · 6月19日35

2026 and we're out here writing security postmortems that start with "the AI was, unfortunately, very helpful"

译2025年，攻击者通过邮件对Microsoft 365 Copilot实施社会工程攻击——AI读取并执行了恶意指令，受害者无需任何点击。到2026年，同样的手法正被用于攻击AI智能体（Agent）。为此，OrcaRouter在旗下平台免费提供Firewall（防火墙）和Guardrails（护栏）保护智能体，用户无需改代码，只需在控制台切换开关即可启用。

fofr@fofrAI · 6月19日13

I got agents in my agents training agents for my agents

译我的智能体里有智能体，它们正在为我的智能体训练智能体。

宝玉@dotey · 6月19日65

Claude Code 推出 Artifact 功能：AI 编程从终端走向可视化协作 Claude Code 现在可以把工作过程生成 Artifact，简单说就是一个实时更新的网页。PR 走查、系统架构说明、调试时间线、发布清单，这些原本只存在于终端会话里的东西，现在变成一个链接，发给团队成员直接打开就能看。 生成 Artifact 时，Claude Code 会用到当前会话的完整上下文，包括代码库、已接入的外部工具（比如监控系统）和对话内容。一个事故调查页面可以同时展示出错的测试代码、监控工具里的错误曲线，以及 Claude 的根因分析推理，不需要你手动接数据源或搭基础设施。 Artifact 会随会话进展自动更新。每次更新后，打开页面的人立刻能看到最新版本，同一个链接始终有效，历史版本也可以随时回溯。 Anthropic 在内部测试中发现，最高频的场景是调试。一个工程师在早会前启动事故排查，Claude Code 查着日志就发布了一个 Artifact：时间线、可疑提交、错误率图表。她把链接丢进群里，等早会开始时页面已经更新了两次。团队不用再听"我来介绍一下 agent 查到了什么"，所有人看着同一个页面讨论就行。 这其实解决了 AI 编程工具的一个实际问题：agent 在终端里干了很多活，但成果只有操作者自己看得到，团队协作时还得靠人肉"翻译"。Artifact 把这个中间环节省了。 安全方面，Artifact 默认私有，只有同组织内认证成员可以查看，不能公开。管理员可以控制组织级开关、设置角色权限和数据保留策略。 除了调试和 PR 走查，Anthropic 列出的用例还包括：法务用它审计所有第三方依赖的开源许可证，安全团队做代码审查报告并把每个发现链接到具体代码行，平台财务从 Terraform 代码里提取云资源成本分布，设计师用真实组件库生成多套 UI 方案直接挑选。 目前 Artifact 功能以 beta 形式向 Claude Team 和 Enterprise 组织开放，可通过 Claude Code CLI 和桌面应用生成，页面在任何浏览器里查看。个人用户暂时用不了。

译Claude Code 新增 Artifact 功能，可将终端会话中的 PR 走查、调试时间线等过程生成实时更新的交互页面，并通过私有链接分享给团队成员。Artifact 利用当前会话的完整上下文（代码库、外部工具、对话），随会话自动更新，支持历史版本回溯。默认私有，仅同组织认证成员可见。该功能以 beta 形式向 Claude Team 和 Enterprise 组织开放，通过 CLI 和桌面应用生成，个人用户暂不可用。Anthropic 内部测试显示调试场景最高频。

宝玉@dotey · 6月19日64

OpenAI Codex 上线了 Record & Replay 功能：在 Mac 上把一个重复性操作演示一遍，Codex 会观察你的操作过程，自动生成一个可复用的 Skill。下次遇到同样的任务，换一组输入参数，Codex 就能替你重新执行。 目前仅限 macOS，欧盟地区暂不可用，使用前需要先开启 Computer Use。 这个功能解决的问题很具体。很多日常工作流程步骤固定但难以用文字描述清楚：报销填单要选对科目和审批人，发布视频要按固定顺序填标题、标签、缩略图，创建 issue 要勾选特定的标签和指派人。以前想让 AI 帮你做这些事，你得把每一步写成精确的指令。Record & Replay 的思路是，与其写说明书，不如做一遍给它看。 操作流程不复杂。在 Codex 桌面端打开 Plugins，点加号菜单，选 Record a skill，然后正常在 Mac 上完成一遍操作。完成后停止录制，Codex 会分析你的操作，生成一份 Skill 文件，里面包含触发条件、所需输入、执行步骤和验证方式。这份 Skill 可以检查、可以编辑，不是黑盒。 重放的时候，开一个新对话，告诉 Codex 用这个 Skill，给它这次不同的参数就行。Codex 会结合 Computer Use（桌面操控）、浏览器操作和已连接的 plugin 来完成任务。

译OpenAI Codex 新增 Record & Replay 功能。用户在 Mac 上演示一遍重复性操作（如报销填单），Codex 自动生成可检查、可编辑的 Skill 文件，内含触发条件、输入参数、执行步骤和验证方式。重放时，用户在新对话中指定该 Skill 并提供不同参数，Codex 即结合 Computer Use、浏览器和已连接 plugin 完成任务。目前仅支持 macOS，欧盟地区暂不可用，使用前需开启 Computer Use。该功能无需精确指令，通过“做一遍”替代“写说明书”实现工作流复用。

Greg Brockman@gdb · 6月19日63

you can now teach Codex by demonstration:

译现在你可以通过演示来教 Codex：

Rohan Paul@rohanpaul_ai · 6月19日55

Agents can now have their own email! @atomic_mail just launched something to fix a missing piece in agentic workflows: agents need inboxes of their own, not borrowed human ones. So Atomic Mail connects to popular agents like Claude Desktop, Cursor, OpenAI-based agents, and custom API agents through MCP, Agent Skill, or direct JMAP/REST API. With one prompt, an agent can get its own inbox and start handling workflows like newsletter monitoring, job applications, invoice processing, customer support, competitive tracking, and human escalation over email. Their smart design choice is PoW (Proof-of-Work) plus reputation, because single good agents move normally while mass spam attempts become expensive and low-reputation senders get throttled. PoW here means each agent has to do a tiny computational task before sending email, which is cheap for one real agent but expensive for someone trying to spin up 1M spam agents. And for "Reputation" agents need to keep sending normal, non-flagged emails to earn more trust over time, while suspicious agents get slowed down or blocked.

译Atomic Mail 发布 API-first 邮箱，专供 AI 智能体独立使用，不再借用人类邮箱。智能体通过 MCP、Agent Skill 或 JMAP/REST API 一键获取收件箱，支持 Claude Desktop、Cursor、OpenAI 等主流 Agent。典型场景包括新闻监控、求职、发票处理和客户支持。防滥用机制采用 PoW（工作量证明）+ 声誉系统：智能体发信前需执行小额计算，对合法 Agent 成本低，但批量垃圾发送成本高昂；声誉随行为动态调整，可疑发送者被限速或封禁。目前免费公测中。

🚨 AI News | TestingCatalog@testingcatalog · 6月19日62

Atomic Mail has launched its API-first email, built for AI agents, in which inboxes belong to the agents themselves. > Atomic Mail operates through MCPs and Agent Skills. > The agent registers its own account and sends, receives, and replies without a person in the loop. Agents are taking over 👀

译Atomic Mail 发布 API-first 邮件服务，专为 AI 智能体设计。智能体可通过 MCP 或 Agent Skill 一键接入，拥有独立收件箱，无需人工参与即可自动收发和回复邮件，实现全自动化工作流。目前该服务处于免费开放 alpha 阶段。