5.7
Unattended: when it must stop無人值守:什麼時候必須停无人值守:什么时候必须停
This chapter picks up the unattended run from Use subagents sparingly: a hook keeps the agent working down a to-do list while nobody watches. That chapter showed how it runs. This one is about how it ends.
這一章接著 慎用子 agent 裡的無人值守的執行:一個 hook 讓 agent 在沒人看著的時候,沿著待辦清單繼續做。那一章講它怎麼跑。這一章講它怎麼結束。
这一章接着慎用子 agent里的无人值守的运行:一个 hook 让 agent 在没人看着的时候,沿着待办清单一直干下去。那一章讲了它怎么跑,这一章讲它怎么收场。
The Knowledge經驗分享经验分享
In one sentence
An unattended agent goes only as far as its stop rules reach. Set them in advance as a total budget, not only a step count, and guard against it declaring the job done too early.
一句話
無人值守的 agent,只會走到停止規則所及的地方。事先設好規則,要設成總預算,不只是步數,並且防著它太早宣布完成。
一句话
无人值守的 agent,只能走到它的停止规则管得到的地方。要提前把规则设好,用总预算,而不只是步数;还要防它过早宣布“做完了”。
For leaders
- The decision: before approving an unattended run, set its stop rules in advance, as a total budget and not only a step count, and require a stop to hand back a reason.
- The risk: when you leave, you stop being the stop rule. The run could loop for hours, spend a night's usage on a step that cannot succeed, or stop early and say it is finished. My setup has step and time limits but not a total budget yet, and I call unattended runs beta. I have not measured whether an unattended run beats a person watching to the end.
- The cost of doing it right: a few rules and one budget number per task. The price of tight rules is more stops, and a person on call in the morning. A vague hand-back costs more time than watching would.
- Ask the team: "If this runs overnight and goes wrong, what stops it, and what will I find in the morning?"
給主管
- 要做的決定:批准無人值守的執行之前,先設好它的停止規則,要設成總預算,不只是步數,並要求每次停止都交回一個原因。
- 風險:你一離開,就不再是停止規則了。這次運行可能繞幾個小時,把一整晚的用量花在一個不可能成功的步驟上,也可能太早停下來還說自己做完了。我的設定有步數和時間的上限,但還沒有總預算,我也把無人值守的執行稱為 beta。無人值守的執行是否勝過有人看到最後,我沒有量過。
- 做對的成本:每個任務幾條規則和一個預算數字。規則緊的代價,是更多次停止,以及早上要有一個人待命。含糊的交回,花的時間比看著還多。
- 可以問團隊:「如果這個整晚在跑,結果出了問題,什麼會讓它停下來?早上我會看到什麼?」
写给管理者
- 要拍板的事:批准无人值守的运行之前,先把它的停止规则设好,用总预算,而不只是步数,并要求每次停下都交回原因。
- 风险:你一走,就不再是那条停止规则了。运行可能循环好几个小时,可能在一个注定成不了的步骤上烧掉一晚上的用量,也可能提前停下,还说自己做完了。我的配置有步数和时间的限制,但还没有总预算,我把无人值守的运行叫作 beta。无人值守的运行是否比人盯到最后更好,我没有测过。
- 做对的代价:每个任务几条规则,加一个预算数字。规则收得紧的代价,是停得更多,早上得有人待命。含糊的交回,比盯着看更费时间。
- 可以问团队:“如果这个任务通宵跑、中途出了问题,什么会让它停下来?我早上会看到什么?”
The problem
When you watch an agent, you are the stop rule. You see it go wrong and you press stop. When you leave, that rule leaves with you. What remains is whatever you wrote down before going.
So the question for an unattended run is not "will it work?" It is "what happens when it does not?" It could loop for hours. It could spend a night's worth of usage on a step that cannot succeed. It could hit a choice that only you can make, and make it anyway. Or it could do the opposite: stop early and say it is finished.
Each of these needs a different rule, set before you leave. There are three questions: when must it stop, what does it hand back, and how do we know it is really done.
問題
你看著 agent 的時候,你就是停止規則。你看到它出錯,就按停止。你離開時,這條規則也跟著你走了。剩下的,就是你離開前寫下來的東西。
所以對無人值守的執行,問題不是「它會成功嗎?」而是「它不成功的時候會怎樣?」它可能繞幾個小時。它可能把一整晚的用量花在一個不可能成功的步驟上。它可能碰到只有你能做的選擇,卻自己做了。或者反過來:太早停下來,說自己做完了。
這幾種情況,各需要一條不同的規則,在你離開之前設好。有三個問題:它什麼時候必須停?它交回什麼?我們怎麼知道它真的做完了?
问题
你盯着 agent 的时候,你就是停止规则。你看到它跑偏了,就按停。你一走,这条规则也跟着走了。剩下的,只有你走之前写下的东西。
所以,对无人值守的运行,问题不是“它行不行”,而是“不行的时候会怎样”。它可能循环好几个小时。它可能在一个注定成不了的步骤上,烧掉一晚上的用量。它可能遇到只有你才能做的选择,却自己做了决定。它也可能反过来:提前停下,还说自己做完了。
这几种情况各需要一条不同的规则,而且要在你走之前设好。有三个问题:什么时候必须停,停下时交回什么,以及怎么知道它真的做完了。
How it works
- An unattended run goes along a road from the start to done, with nobody watching.
- Stop 1: the total budget (usage and time, main agent and helpers together) is spent.
- Stop 2: the agent keeps trying things it is not allowed to do.
- Stop 3: it pushes on but no step gets done.
- Stop 4: it reaches a choice that only a person can make.
- Whichever stop it hits, it hands back the reason, the place it reached and the open question.
1. Kinds of stop rule
Each rule catches a different way a run goes wrong. What is common to them: code judges them from facts, not the agent. An agent that is stuck is the worst judge of whether it is stuck.
- The three basic rules. A cap on steps and time, a stop after the guardrails refuse the agent twice in a run, and a stop when no step gets ticked. They are in Use subagents sparingly, with their numbers. (A step is one item on the to-do list. This stop rule is not the breaker of Guard the files that hold the rules, which reacts to one refusal repeating inside a session.)
- The plan changed. The person approved a plan; the run is allowed to carry out that plan. If the plan changes, the permission ends at once.
- The checks are used up. The independent check keeps failing and its limit is reached (Make a pass count).
- The agent says it cannot go on. Some stops the facts cannot show: two tables define a field differently and the plan does not say which to use. Only the agent can see that. So it may stop itself, but only with a reason, and only for the cases that need a person, not for small choices.
These are the numbers in my setup. They are examples, not wisdom: I chose them, and I have not measured whether they are the right ones.
2. A budget is a total, not a count
The rules above count things: steps and refusals. But what you are afraid of is spending. A count does not limit spending. Twenty small steps and twenty steps that each launch helpers are not the same bill.
A budget is a total over usage and time, covering the main agent and all its helpers together. A helper gets what is left, not a new allowance of its own. When the first line is crossed, the run stops.
Here is a way to build it; my own setup does not have it yet (it has the counts above and a time limit). The person sets one task-level budget, in usage and minutes. Before each step, a hook adds up the usage of the main session and every helper session from the platform's own session record. At the line it stops the run and writes "budget" as the reason. Whether helpers' usage shows up in the record in time to stop on, I have not checked.
Usage is also not the same as money: input the provider has cached is read at about a tenth of the base price (Models and cost). I have not checked how Copilot bills it.
Some tools already offer a simple version for non-interactive runs. Claude Code has --max-turns and --max-budget-usd, both for print mode (claude -p) only. The money cap is checked against a client-side estimate, not your bill, and can be passed; spend from subagents counts toward it, and once it is reached no new subagent can start (CLI reference). I have not tried them.
3. What a stop hands back
A run that stops without saying why is a puzzle for the person who comes back. So a stop has to hand back three things:
- Why it stopped, in a word the person can act on: budget, refused, no progress, needs a decision.
- Where it is: the steps done, the step it was on, and the state of the work.
- What a person has to decide, in one sentence.
In my setup, the code writes the reason when it stops on facts, and the agent writes one sentence when it stops itself. The instruction for that sentence is: which step is stuck, why, and what you must decide. "Ran into a problem" is not enough.
The decisions the agent made along the way matter too. For anything the plan left open and the agent chose, it writes a line: what it chose and why. That is the log a person reads on return, and it is what makes unattended work reviewable.
4. Guarding against "done" said too early
The failure on the other side is just as real. Anthropic described it in a long-running coding agent: "a later agent instance would look around, see that progress had been made, and declare the job done" (Effective harnesses for long-running agents).
The agent has a reason to say it is done: the stop is what it was asked for. So a run should not end when the agent says "done". A tick on the list is itself only a claim, as the next paragraphs explain, so the end of a run goes by the facts:
- Every step on the list is ticked.
- The independent check passed, counted by code, on the version of the work as it is now.
- The plan is the one that was approved.
- The write-back plan is made, for a person to read (Two gates).
Only then is "done" a state, not a claim.
This is not airtight. An agent can tick a step without finishing it. The checker reads the whole result at the end, and the person reads the whole diff, but nothing in code proves that step 7 was really done. I treat ticks as claims and the end-of-run check as the thing that counts.
原理
- 無人值守的運行沿著一條路從開始走到完成,沒有人看著。
- 停點 1:總預算(用量和時間,主 agent 和幫手合計)用完了。
- 停點 2:agent 一再嘗試不被允許的事。
- 停點 3:一直往前推,卻沒有完成任何一步。
- 停點 4:遇到只有人才能做的選擇。
- 不管在哪個停點停下,都交回原因、走到的位置和還沒決定的問題。
1. 停止規則的種類
每一條規則,抓的是運行出錯的一種方式。它們的共同點:由程式根據事實來判斷,不是由 agent。卡住的 agent,是判斷自己有沒有卡住最差的人。
- 三條基本規則。步數和時間的上限、一次運行中圍欄拒絕 agent 兩次就停止,以及沒有任何一步被勾掉時停止。它們和數字都在 慎用子 agent 裡。(一步是待辦清單上的一項。這條停止規則,不是 保護規則本身的檔案 裡的斷路器,斷路器處理的是一個會話裡同一個拒絕一再重複。)
- 計畫變了。人批准的是一份計畫;這次運行只被允許執行那份計畫。計畫一變,許可立刻結束。
- 檢查用完了。獨立檢查一直失敗,到了它的上限(讓「通過」可信)。
- agent 說它做不下去了。有些停止,事實顯示不出來:兩張表對同一個欄位的定義不同,計畫沒說該用哪個。只有 agent 看得到這一點。所以它可以自己停下來,但必須附上原因,而且只限於需要人的情況,不是為了小選擇。
這些是我的設定裡的數字。它們是例子,不是智慧:是我選的,我沒有量過它們是不是對的。
2. 預算是總量,不是次數
上面的規則數的是東西:步數和拒絕次數。但你擔心的是花費。次數限制不了花費。二十個小步驟,和二十個各自啟動幫手的步驟,帳單不一樣。
預算是對用量和時間的總量,主 agent 和它所有的幫手合在一起算。幫手拿到的是剩下的,不是自己另有一份新的額度。越過第一條線,運行就停止。
這裡有一種建法;我自己的設定還沒有(它有上面的次數和一個時間上限)。人設一個任務層級的預算,用量和分鐘數。每一步之前,一個 hook 從平台自己的會話紀錄,把主會話和每個幫手會話的用量加起來。到了那條線,它停止運行,並把「budget」寫成原因。幫手的用量會不會及時出現在紀錄裡,讓它來得及據以停止,我沒有檢查過。
用量也不等於錢:供應商快取過的輸入,讀取的價格大約是基本價格的十分之一(選模型:算的是每次成功的成本)。Copilot 怎麼計費,我沒有檢查過。
有些工具已經為非互動的執行,提供了簡單的版本。Claude Code 有 --max-turns 和 --max-budget-usd,兩者都只用於 print 模式(claude -p)。金額上限是拿用戶端的估計值來比對,不是你的帳單,而且可能被超過;子 agent 的花費也算進去,一旦達到上限,就不能再啟動新的子 agent(CLI reference)。我沒有試過它們。
3. 一次停止交回什麼
不說原因就停下來的運行,對回來的人是個謎。所以一次停止要交回三樣東西:
- 為什麼停止,用一個人能據以行動的詞:budget、refused、no progress、needs a decision。
- 現在在哪裡:做完的步驟、它正在做的那一步,以及工作的狀態。
- 人要決定什麼,用一句話。
在我的設定裡,根據事實停止時,原因由程式寫;agent 自己停止時,由 agent 寫一句話。那一句話的指令是:哪一步卡住、為什麼、你必須決定什麼。「遇到了問題」不夠。
agent 一路上做過的決定也很重要。計畫沒定、由 agent 選的任何事,它都寫一行:選了什麼、為什麼。人回來時讀的就是這份紀錄,也是它讓無人值守的工作可以被審查。
4. 防著太早說「做完了」
另一邊的失敗一樣真實。Anthropic 在一個長時間運行的寫程式 agent 上描述過:「後來的 agent 實例會看一圈,見到已經有進展,就宣布工作完成」(Effective harnesses for long-running agents)。
agent 有理由說自己做完了:停下來正是它被要求的。所以運行不應該在 agent 說「做完了」時結束。清單上的勾,本身也只是一個說法,下面幾段會解釋,所以運行的結束要看事實:
- 清單上的每一步都勾了。
- 獨立檢查通過了,由程式計數,對的是現在這個樣子的工作。
- 計畫就是被批准的那份。
- 寫回的計畫已經做好,給人讀(兩道門:人在哪裡批准)。
這時「做完了」才是一個狀態,不是一個說法。
這並不密不透風。agent 可以勾掉一步卻沒做完。檢查者在最後讀整個結果,人讀整份 diff,但程式裡沒有任何東西證明第 7 步真的做了。我把勾當成說法,把運行結束時的檢查當成算數的東西。
原理
- 无人值守的运行沿着一条路从开始走到完成,没有人看着。
- 停点 1:总预算(用量和时间,主 agent 和帮手合计)用完了。
- 停点 2:agent 一再尝试不被允许的事。
- 停点 3:一直往前推,却没有完成任何一步。
- 停点 4:遇到只有人才能做的选择。
- 不管在哪个停点停下,都交回原因、走到的位置和还没决定的问题。
1. 停止规则的种类
每条规则抓一种运行出错的方式。它们的共同点是:由代码根据事实来判断,不由 agent 判断。一个卡住的 agent,最没资格判断自己是不是卡住了。
- 三条基本规则。步数和时间的上限;一次运行里护栏拒绝了 agent 两次就停;没有任何一步被勾掉就停。它们和具体数字都在慎用子 agent里。(一步是待办清单上的一项。这条停止规则不是保护规则本身的文件里的熔断器,那个熔断器针对的是同一个会话里同一次拒绝反复出现。)
- 计划变了。人批准的是一份计划,运行只被允许执行这份计划。计划一变,授权立刻失效。
- 检查次数用完了。独立检查一直不通过,达到了它的上限(见让“通过”可信)。
- agent 说它走不下去了。有些停止,事实显示不出来:两张表对同一个字段的定义不一样,计划里没说用哪个。只有 agent 看得到这一点。所以它可以自己停,但必须写明原因,而且只限于需要人的情况,小事不行。
以上是我配置里的数字。它们只是例子,不是什么真理:是我选的,我没有测过它们是不是合适。
2. 预算是总量,不是次数
上面的规则数的是东西:步数和拒绝次数。但你怕的是花费。次数限制不了花费。二十个小步骤,和二十个每步都启动帮手的步骤,账单不一样。
预算是对用量和时间的一个总量,把主 agent 和它所有的帮手合在一起算。帮手拿到的是剩下的部分,而不是自己另有一份额度。越过第一条线,运行就停。
下面是一种搭法;我自己的配置还没有(它有上面那些次数限制和一个时间限制)。由人给每个任务设一个预算,用量和分钟数各一个。每一步之前,hook 根据平台自己的会话记录,把主会话和每个帮手会话的用量加起来。到了线,就停下运行,把“预算”写成原因。帮手的用量能不能及时出现在记录里、赶得上叫停,我没有查过。
用量也不等于钱:服务商已缓存的输入,读取价格约是基础价格的十分之一(见选模型:看每次成功的成本)。Copilot 怎么计这部分,我没有查过。
有些工具已经为非交互的运行提供了简单的版本。Claude Code 有 --max-turns 和 --max-budget-usd,都只用于 print 模式(claude -p)。金额上限对照的是客户端的估算,不是你的账单,可能被超过;子 agent 的花费也算进去,一旦达到上限,就不能再启动新的子 agent(见 CLI reference)。我没有试过。
3. 停下时交回什么
一次不说明原因就停下的运行,是留给回来的人的一个谜。所以停下时必须交回三样东西:
- 为什么停,用一个人能据此行动的词:预算、被拒绝、没有进展、需要决定。
- 走到哪了:做完的步骤、正在做的那一步,以及工作的状态。
- 人要决定什么,一句话。
在我的配置里,由事实触发的停止,原因由代码写;agent 自己停的时候,由它写一句话。这句话的指令是:哪一步卡住了,为什么,你要决定什么。“遇到了问题”不够。
它一路上做的决定也很重要。计划没定、由 agent 自己选的每一处,它都写一行:选了什么,为什么。这是人回来时读的日志,也是无人值守的工作能被复核的原因。
4. 防止过早说“做完了”
另一边的失败同样真实。Anthropic 在一个长时间运行的编程 agent 上描述过:“后来的 agent 实例四下看看,发现已经有了进展,就宣布任务完成”(Effective harnesses for long-running agents)。
agent 有理由说自己做完了:停下就是别人要它做的。所以运行不该在 agent 说“做完了”的时候结束。清单上的一个勾,本身也只是一个声明(下面几段会讲),所以运行的结束要看事实:
- 清单上的每一步都勾掉了。
- 独立检查通过了,由代码计数,针对的是工作现在的这个版本。
- 计划就是当时批准的那一份。
- 写回计划已经做好,供人阅读(见两道门:人在哪里审批)。
到这时,“做完了”才是一种状态,而不是一个声明。
这并不严密。agent 可以不完成就勾掉一步。检查者在最后读整个结果,人读整个 diff,但没有任何代码能证明第 7 步真的做了。我把勾当作声明,把运行结束时的检查当作算数的东西。
Costs and traps
More rules, fewer wins. A run with tight stop rules will stop on many nights and hand back little. The price of safe is a person on call in the morning. I have not measured whether an unattended run is better than a person watching to the end. In my setup it is still called beta for this reason.
A stop is not an answer. The run stops, and the work is half done. The snapshots taken at the gates (Two gates) are where a person can look at the state it stopped in. If the hand-back is vague, it costs the person more time than watching would.
Some work should not run unattended at all. The three points of Two gates apply: work that spends real money, grants power such as writing to a shared repository, or cannot be undone needs a person, however good the stop rules are.
Do not take a detour to avoid a refusal. A refusal is the system telling you a step is out of scope. The rule I give the agent is: change it once as the reason says; if that does not work, stop.
代價和陷阱
規則越多,贏的越少。停止規則緊的運行,很多個晚上都會停下來,交回的很少。安全的代價,是早上要有一個人待命。無人值守的執行是否比有人看到最後更好,我沒有量過。在我的設定裡,它因此仍被稱為 beta。
停止不是答案。運行停了,工作只做了一半。在門上拍的快照(兩道門:人在哪裡批准),是人可以看它停下來時狀態的地方。如果交回得含糊,花掉人的時間比看著還多。
有些工作根本不該無人值守。兩道門:人在哪裡批准 的那三個點適用:花真錢、給權力(例如寫入共用的倉庫)、或不能反悔的工作,不管停止規則多好,都需要人。
不要為了避開拒絕而繞路。拒絕是系統在告訴你,這一步超出範圍。我給 agent 的規則是:照原因說的改一次;如果不行,就停下來。
代价和坑
规则越多,赢得越少。停止规则收得紧的运行,会在很多个晚上停下来,交回的东西很少。安全的代价,是早上得有人待命。无人值守是否比人盯到最后更好,我没有测过。在我的配置里,正是因为这个,它仍然叫 beta。
停下不等于有了答案。运行停了,活只做了一半。在关卡处拍下的快照(见两道门:人在哪里审批),是人查看它停下时状态的地方。如果交回的内容含糊,花在人身上的时间比盯着看更多。
有些活根本不该无人值守。两道门:人在哪里审批里的三点在这里同样适用:花真钱、授予权力(比如写入共享仓库)、或者无法撤销的活,不管停止规则多好,都需要人。
别为了躲开拒绝而绕路。拒绝,是系统在告诉你这一步超出范围。我给 agent 定的规则是:按理由说的改一次;还不行,就停。
When to delete it
The stop rules exist because the platform does not provide them. If the platform gives you a total budget over the whole run, helpers included, use it. The stop-on-fact idea stays: the agent's "I'm done" is not a finish line.
什麼時候可以刪掉
停止規則存在,是因為平台沒有提供它們。如果平台給你一個涵蓋整次運行、包括幫手的總預算,就用它。根據事實停止的想法會留下:agent 的「我做完了」不是終點線。
什么时候可以删掉
这些停止规则存在,是因为平台没有提供它们。如果平台提供覆盖整个运行(包括帮手)的总预算,就用平台的。基于事实来停的想法还在:agent 说的“我做完了”不是终点线。
Try it on your own setup
No harness needed. Open your agent in your own repository and paste:
Find every place in this project where an agent can run without a person watching: scheduled jobs, CI steps that call an agent, auto-approve or autopilot settings, loops, background tasks. For each, tell me what stops it (a step or time limit, a spend limit, a refusal count, a check), whether the limit covers helper agents too, and what it leaves behind when it stops: reason, state, and the decision a person must make. Flag any run with no stop rule at all. Do not change any files and do not start any run.在你自己的環境試試
不用裝 harness。在你自己的倉庫裡打開 agent,貼上:
找出這個專案裡,agent 可以在沒有人看著的情況下執行的每個地方:排程的工作、呼叫 agent 的 CI 步驟、自動批准或 autopilot 的設定、迴圈、背景任務。對每一個,告訴我什麼讓它停下來(步數或時間上限、花費上限、拒絕次數、某個檢查)、這個上限有沒有涵蓋幫手 agent,以及它停下來時留下什麼:原因、狀態,以及人必須做的決定。標出完全沒有停止規則的運行。不要改任何檔案,也不要啟動任何運行。在你自己的环境里试试
不用装 harness。在你自己的仓库里打开 agent,粘贴:
找出这个项目里 agent 可以在没人看着的情况下运行的每一处:定时任务、调用 agent 的 CI 步骤、自动批准或 autopilot 的设置、循环、后台任务。对每一处,告诉我是什么让它停下(步数或时间上限、花费上限、拒绝次数、某项检查),这个上限是否也覆盖帮手 agent,以及停下时它留下了什么:原因、状态,以及人必须做的决定。把完全没有停止规则的运行标出来。不要修改任何文件,也不要启动任何运行。Go deeper
- Anthropic: Effective harnesses for long-running agents
- Claude Code docs: CLI reference (
--max-turns,--max-budget-usd)
延伸閱讀
- Anthropic:Effective harnesses for long-running agents
- Claude Code 文件:CLI reference(
--max-turns、--max-budget-usd)
延伸阅读
- Anthropic:Effective harnesses for long-running agents
- Claude Code 文档:CLI reference(
--max-turns、--max-budget-usd)
You can stop here: that is the whole idea. The next part shows where it runs, so you can look inside.讀到這裡就夠了,這就是整個想法。下一部分告訴你它在哪裡運行,可以進去看看。读到这里就够了,核心思路就是这些。下一部分告诉你它在哪里跑,可以进去看看。
In my practice (Copilot Harness)實作实战
Copilot Harness is my open-source harness for VS Code Copilot.
Repository: https://github.com/Smars-Bin-Hu/copilot-agentic-harness
Get started: clone it, open it in VS Code, and type /harness-rookie-get-me-ready in Copilot Chat. You need Python 3.9 or later and git.
Copilot Harness 是我開源的 VS Code Copilot harness。
倉庫: https://github.com/Smars-Bin-Hu/copilot-agentic-harness
開始:clone 下來,用 VS Code 打開,在 Copilot Chat 裡輸入 /harness-rookie-get-me-ready。需要 Python 3.9 以上和 git。
Copilot Harness 是我开源的 VS Code Copilot harness。
仓库: https://github.com/Smars-Bin-Hu/copilot-agentic-harness
上手:把仓库 clone 下来,用 VS Code 打开,在 Copilot Chat 里输入 /harness-rookie-get-me-ready。需要 Python 3.9 及以上版本和 git。
Explore it in the harness
The stop rules, the facts that decide each stop, and what the agent writes when it stops itself all run in Copilot Harness (the unattended run is in beta there). The budget over helpers is not built yet. The harness can teach the rest from the inside, with the real files. After the setup above, type:
/harness-rookie-wondering I have read the chapter "Unattended: when it must stop". Teach me how this harness's unattended run (autorun) decides when to stop (topics 11 and 15): the stop reasons, who judges each one, and what is handed back. Open the real files with me and draw how the pieces fit together.It teaches one small piece at a time, stops to ask if you are following, and opens the files with you.
在 harness 裡探索
停止規則、決定每次停止的事實,以及 agent 自己停止時寫下的東西,都在 Copilot Harness 裡執行(無人值守的執行在那裡是 beta)。涵蓋幫手的預算還沒做。其餘的,harness 可以從裡面教你,附上真實的檔案。照上面的說明準備好之後,輸入:
/harness-rookie-wondering 我讀完了「無人值守:什麼時候必須停」這一章。請教我這個 harness 的無人值守執行(autorun)怎麼決定什麼時候停止(主題 11 和 15):有哪些停止的原因、每一個由誰判斷,以及交回什麼。帶我打開真實的檔案,並畫出這些部分怎麼組合在一起。它一次教一小塊,停下來確認你跟得上,然後和你一起打開檔案。
在 harness 里探索
停止规则、决定每次停止的事实,以及 agent 自己停下时写的内容,都在 Copilot Harness 里跑着(那里的无人值守的运行是 beta)。针对帮手的预算还没有做。其余的,harness 可以从内部教你,配上真实的文件。按上面的说明准备好之后,输入:
/harness-rookie-wondering 我读完了“无人值守:什么时候必须停”这一章。请教我这个 harness 的无人值守的运行(autorun)是怎么决定什么时候停的(主题 11 和 15):有哪些停止原因,每一个由谁来判断,以及交回什么。和我一起打开真实的文件,并画出各部分是怎么拼在一起的。它一次只教一小块,停下来确认你跟上了,再和你一起打开文件。