작업이 끝났거나 막혔을 때 루프를 멈춘다

읽는 데 약 24분분 걸린다, 6절에 4개 예제이(가) 있음.

2026.11.2판 예제 통과 2026년 11월 20 64개 예제 중 64개 통과 변경 사항

AI로 번역함. 영어 원문을 사람이 검증함. 우리가 책을 만드는 방식

영어판 2026.11.2판을 번역한 것이다. 원문 읽기

이 장을 마치면 하네스가 실행마다 기록하는 단어 하나만으로 그 실행이 멈춘 이유를 말할 수 있고, 진전이 멈춘 실행을 끝내는 규칙 두 가지를 추가할 수 있다.

1장에서 만든 루프는 세 가지 방식으로 실행을 끝낸다. 모델이 finish를 호출하거나, 실행이 단계 상한인 8에 도달하거나, 모델이 호출을 하지 않는 일이 두 번 일어나는 경우다. 이는 작업을 마치는 모델은 다룬다. 하지만 같은 편집을 계속 보내는 모델은 다루지 못한다. 편집 대상 텍스트를 찾지 못하는 편집이 그런 상황을 부른다. 1장의 도구에는 편집이 없으므로 이 경우는 작업 집합에서 나온다. 작업 집합은 에이전트 테스트에서 채점하는 20개 작업이며, 편집 도구를 포함한 도구 집합 v1로 실행한다. 이어지는 예제인 unitcraft는 작은 단위 라이브러리이고, 눈에 보이는 테스트 모음이 변경할 때마다 개수를 알려 준다. 이 예제에서 그런 식으로 막힌 실행은 상한까지 가고, 그 실행의 끝에 대한 유일한 기록은 상한 때문에 끝났다는 사실뿐이다. 낭비된 단계 하나하나는 모델 호출 한 번이자, 검토자가 읽어야 하는 기록의 한 줄이다. 이 장에서는 루프가 실행을 끝내는 방식에 이름을 붙이고, 막힌 실행을 일찍 끝내는 규칙 두 가지를 추가하며, 그 규칙이 작업 집합에서 어떤 효과를 내는지 측정한다.

실행이 끝나는 방식

모든 실행은 명시된 하나의 이유로 끝나며, 하네스는 그 이유를 실행의 ended 필드에 기록한다. 이유 가운데 둘은 모델의 선택이다. 모델이 finish를 호출해 실행을 끝내거나, 사람에게 던질 질문과 함께 ask_user를 호출한다. 셋은 하네스가 정한 한도로, 단계 예산, 반복 호출 규칙, 진전 없음 규칙이다. 여섯 번째인 no_tool_call는 모델이 호출을 하지 않을 때 설정된다. 루프는 이 여섯 가지를 설정하며, 권한 게이트는 6장에서 일곱 번째를 추가한다. 표에 여섯 가지를 정리했다.

ended 설정되는 때 확인하는 곳
finish 모델이 finish를 호출하여 실행을 끝낼 때 과제 집합 집계
ask_user 모델이 질문과 함께 ask_user를 호출하고, 변경은 이루어지지 않을 때 과제 집합 집계
step_cap 실행이 단계 예산에 도달할 때 budget-stops-a-loop
repeated_call 같은 호출이 연속으로 세 번 나올 때 repeated-call-stops
no_progress 연속된 두 번의 편집이 테스트 수를 그대로 둘 때 no-progress-stops
no_tool_call 모델이 연속으로 두 번 호출을 하지 않을 때 과제 집합 집계, 여기서는 0이다

과제 집합 집계는 묻기, 멈추기, 세기의 마지막 예제가 출력하는 줄이다. 과제 집합이 사용하는 도구 집합 v1에서 finish는 요약만 받는다. 이 도구는 실행이 임시 사본에 이미 가한 편집의 요약과 함께 실행을 끝내며, 파일은 쓰지 않는다. 1장의 finish는 실행을 끝내기 전에 파일 하나도 썼다. 이 장에서 측정하는 도구 집합은 그렇게 하지 않는다.

같은 단계에서 둘 이상의 종료 조건이 적용되면 루프는 정해진 순서로 확인한다. finish 또는 ask_user 호출을 먼저 처리하고, 그다음 반복 호출 규칙, 그다음 진전 없음 규칙을 처리한다. 예산은 루프가 단계를 모두 소진했을 때 적용되므로 마지막에 확인한다. 이 순서는 두 종료 조건이 한 단계에서 만날 때만 의미가 있으며, 이 장의 나머지는 단일한 경우만 다룬다.

호출 없는 응답은 한 번 재시도할 기회를 얻는다. 호출 없는 응답이 연속으로 두 번 나오면 실행은 no_tool_call로 끝난다. 이 장의 어떤 예제도 여기에 이르지 않으므로, 이곳의 내용은 이에 의존하지 않는다.

각 종료는 마지막 응답 속의 문장이 아니라 하나의 값이므로, 보고서는 그 응답을 읽지 않고도 어떤 종료가 일어났는지 말할 수 있다. 실제 운영에서는 이러한 종료 사이의 차이를 밖에서 알아보기 어렵다. step_cap로 끝난 실행은 끝내지 못한 느린 실행처럼 보이고, 최종 메시지만 읽는 검토자는 이를 곧 끝날 실행과 구별할 수 없다. 보고서에서 그 차이를 드러내는 것이 ended 값이며, 실행이 과제에 비해 비용이 지나치게 들 때 가장 먼저 확인할 대상이다.

이 이름들은 이 장을 넘어서도 중요하다. 권한 게이트는 finish 호출이 제안한 변경이 사람이 승인할 때까지 대기하는 곳이다. 서브에이전트와 인계는 중단을 사람에게 던지는 질문으로 바꾸고, 에이전트 테스트는 종료를 집계한다. 각각 이 값들을 읽으므로, 여기서 이름을 바꾸면 그곳에서도 바뀐다.

여기서는 하네스가 관찰할 수 있는 종료를 나열할 뿐, 실행이 실패할 수 있는 모든 이유를 나열하지는 않는다. 틀린 답을 내놓고 finish를 호출한 모델은 finish로 끝나며, 실패했다는 사실은 최종 사본을 채점하는 숨겨진 테스트인 검사만이 보여 준다. 그래서 완료 수는 ended 값이 아니라 검사에서 나오며, 아래의 작업 규칙이 이 점으로 돌아온다. Agent SDK 문서 How the agent loop works도 종료를 같은 방식으로 설명한다. 턴 한도에 도달한 실행은 하위 유형이 error_max_turns인 결과로 끝나며 최종 응답이 없다. 그 SDK에서 턴은 루프를 한 번 지나는 것, 즉 모델 응답 하나와 그 도구 호출이며, max_turns는 이 횟수에 텍스트만 있는 마지막 응답 몫으로 하나를 더해 센다. 여기서는 그 한 번이 한 단계이다. 이 책은 "턴"이라는 말을 과제를 준 사람과 주고받는 교환에 쓴다. 같은 문서는 한도가 없는 루프가 열린 형태의 프롬프트에서 오래 실행될 수 있다고 경고한다. 이 책은 SDK를 사용하지 않으므로, 그 문서는 설계의 근거로만 인용하고 코드를 위해 인용하지는 않는다.

작업 규칙: 모든 실행마다 ended 값을 하나씩 기록하고, 이 값 없이는 실행 결과를 보고하지 않는다. 실행의 완료 여부는 ended 값만으로 판단하지 말고 점수의 규칙으로 센다.

예산은 단계를 센다

모델이 finish을 호출하지 않으면 루프에는 멈출 이유가 없다. 그러므로 루프에는 멈추게 하는 횟수 제한이 필요하다. 한 단계는 모델에 대한 호출 한 번과 그 호출이 돌려주는 응답이다. 단계 예산은 한 번의 실행이 거칠 수 있는 최대 단계 수이며, 루프는 그 수에 도달하면 멈춘다. 단계는 시간이 아니라 횟수로 센다. 루프는 시계를 읽지 않는다.

이 장의 마지막 예제가 세는 20개의 과제인 과제 집합은 도구 집합 v1에서 16단계의 예산으로 실행한다. 1장은 더 작은 예산인 8을 사용한다.

1장에서 기록한 T-01의 실행은 예산이 작동하는 모습을 보여 준다. 모델인 Qwen3-4B-Instruct-2507은 오픈 모델이며, 응답을 기록해 두었다가 여기서 재생하므로 이 장의 모든 실행은 어느 기계에서나 같은 출력을 얻는다. 이 기록에서 모델은 여덟 단계 안에 끝내지 못했다. 마지막 단계는 형식이 잘못된 도구 호출이었고, 하네스는 이를 거부했다. 다른 규칙 없이 예산만 적용해 실행을 재생하면, 출력은 상한이 어디에서 실행을 끝내는지 보여 준다.

budget-stops-a-loop.py Python 3.12.15 · pydantic 2.14.3 통과
"""The chapter 1 recorded run of T-01 under its step budget of 8. The budget ends the run as step_cap, with no finish;the last line shows the model's final step, a call the harness refused, and the budget ended the run after it."""from lib.case import load_tasksfrom lib.loop import run_taskfrom lib.models import ReplayModelfrom lib.tools import CH1from lib.trace import IdCountertask = load_tasks(only=["T-01"])[0]run = run_task(ReplayModel("chapter-1-t01", "T-01"), task, CH1, max_steps=CH1.step_cap, ids=IdCounter())print("budget (steps):", CH1.step_cap)print("steps:", run.steps)print("tool calls:", run.tool_calls)print("ended:", run.ended)print("last step:", run.trace.lines()[-1])assert run.ended == "step_cap" and run.steps == CH1.step_cap, "the budget should stop the run on step 8"assert not run.summary, "a budget stop carries no summary"
출력python budget-stops-a-loop.py
budget (steps): 8
steps: 8
tool calls: 8
ended: step_cap
last step: step 8: malformed: error: malformed call

실행은 step_cap(으)로 끝나며, 8단계와 도구 호출 8회를 거쳤고 예산은 8이다. 각 단계가 요청을 한 번씩 보냈으므로 두 횟수는 일치한다. 눈여겨볼 부분은 마지막 줄이다. 모델의 마지막 응답은 하네스가 해석할 수 없는 호출이었고, 실행을 끝낸 것은 예산 하나뿐이었다. 모델이 끝냈다고 말해 주는 내용은 기록 어디에도 없다.

단계 예산은 시간을 제한하지 않으며 토큰도 제한하지 않는다. 멈춰 버린 도구는 반환할 때까지 해당 단계를 붙들고 있으므로, 타임아웃은 샌드박스의 몫이며 샌드박스와 비밀 값에서 다룬다. 긴 응답은 한 단계 안에서 더 많은 토큰을 쓰는데, 토큰을 세는 일은 컨텍스트 예산이 맡는다. 예산은 모델 호출만 제한하고 그 밖의 것은 제한하지 않는다. 따라서 예산에 도달한 실행은 호출을 모두 썼다는 것만 알려 줄 뿐, 그 이유에 대해서는 더 알려 주는 바가 없다.

형식이 잘못된 응답도 센다. 하네스가 해석하지 못하는 응답도 모델 호출이므로 한 단계를 소비하고, 예산은 이를 센다. 하네스가 읽지 못하는 호출을 계속 만들어 내는 모델은, 올바른 호출을 계속 반복하는 모델과 똑같이 예산에 도달한다. 둘 다 step_cap(으)로 끝나므로, 둘 중 어느 쪽이 일어났는지는 마지막 몇 단계만이 보여 준다. 올바른 호출의 반복인지, 하네스가 읽지 못한 호출인지가 그것이다.

작업 규칙: 단계 예산은 추측이 아니라 자신의 과제에서 얻은 실행 결과로 정한다. 통과한 실행이 필요로 한 최대 단계 수를 구하고 그 수보다 여유를 더 두되, 그 여유가 무엇을 위한 것인지를 코드에 적어 둔다.

같은 호출, 다시

도구가 실패하는 것을 본 모델이 같은 호출을 계속 되풀이해서 보낼 수 있고, 루프는 예산이 실행을 끝낼 때까지 그 호출을 하나도 빠짐없이 실행한다. 모델이 자신이 반복하고 있음을 알아차릴 것이라고 생각하기 쉽다. Yao 등이 쓴 ReAct 논문(2022, ICLR 2023 발표)은 반복을 빈번한 오류 패턴으로 보고한다. 질의응답 실행에서 모델이 이미 만들어 낸 생각과 행동을 거듭 생성했다는 것이다. 이 논문의 과제는 질의응답과 의사 결정이지 코드가 아니다. 따라서 이 논문은 반복을 주의해서 살펴야 할 이유를 알려 줄 뿐, 반복의 발생 비율은 알려 주지 않는다. 출처는 ReAct: Synergizing Reasoning and Acting in Language Models이다. 하니스는 반복을 스스로 감지해야 한다.

이 책이 쓰는 규칙은 단순하다. 같은 호출이 연속으로 세 번 나오면 실행을 repeated_call로 끝낸다. 도구 이름이 같고 인자가 같으면 같은 호출이다. 인자는 키를 정렬해서 비교한다. 이 정렬은 중요하다. 두 응답이 같은 인자를 담고 있어도 키의 순서가 다를 수 있으며, 그러면 호출은 같은데도 원문 텍스트는 달라진다. 이 책이 고정한 Python 버전 3.12.15에서 json.dumps는 같은 두 키를 두 가지 순서로 넣으면 서로 다른 두 문자열을 내놓는다. 그 결과가 plain dumps equal: False이다. 키를 정렬하면 문자열이 하나가 된다. 그 결과가 sort_keys dumps equal: True이다. 이것은 우리가 실행해 본 확인이지 이 책의 예제가 아니므로, 독자가 되풀이해 볼 수 있는 점검으로 읽으면 된다.

3은 이 책의 임곗값일 뿐 고정된 값이 아니다. 이는 판단의 문제이며, 아래의 작업 규칙이 언제 바꿀지 알려 준다. 앞선 호출과 다른 호출이 파싱되면 횟수를 다시 센다. 형식이 깨진 호출 블록이 담긴 응답도 마찬가지다. 이런 응답에는 비교할 파싱된 호출이 없다. 토큰 한도에서 잘린 응답이나 호출이 없는 응답은 연속 횟수를 그대로 둔다. 루프는 이런 응답에서 연속 호출 검사를 건너뛰므로, 그런 응답을 사이에 두고 양쪽에 있는 같은 호출은 함께 센다.

T-01은 같은 호출을 연속으로 세 번 보내는 일이 없으므로, 이 예제는 모델이 그렇게 하는 T-02를 재생한다.

repeated-call-stops.py Python 3.12.15 · pydantic 2.14.3 통과
"""The recorded run of T-02 with and without the repeated-call rule. Three identical calls in a row end the run asrepeated_call. The rule compares the name and the sorted arguments, so reordered keys still count as the same call."""from lib.case import load_tasksfrom lib.loop import Stops, run_taskfrom lib.models import ReplayModelfrom lib.tools import V1from lib.trace import IdCountertask = load_tasks(only=["T-02"])[0]def replay(stops: Stops):    ids = IdCounter()    ids.next("run")  # the recording numbers its runs in task order, so T-02 is run-0002: skip T-01's number    return run_task(ReplayModel("task-set", "T-02"), task, V1, max_steps=V1.step_cap, ids=ids, stops=stops)plain = replay(Stops())print("without the rule, ended:", plain.ended, "at step", plain.steps)run = replay(Stops(repeat_limit=3))print("with the rule, ended:", run.ended, "at step", run.steps)print("repeated call:", run.stuck_on)print("first of the identical calls: step", run.streak_from)print("identical calls in a row:", run.steps - run.streak_from + 1)print("last two steps:", *run.trace.lines()[-2:], sep="\n  ")assert run.ended == "repeated_call" and run.streak_from == 11 and run.steps == 13
출력python repeated-call-stops.py
without the rule, ended: step_cap at step 16
with the rule, ended: repeated_call at step 13
repeated call: edit_file
first of the identical calls: step 11
identical calls in a row: 3
last two steps:
  step 12: edit_file: error: old text not found in unitcraft/format.py
  step 13: edit_file: error: old text not found in unitcraft/format.py

규칙이 없으면 실행은 step_cap at step 16(으)로 끝난다. 규칙이 있으면 실행은 repeated_call at step 13(으)로 끝난다. 핵심은 마지막 단계들에 있다. 같은 edit_file 호출이 다시 전송되고, 매번 old text not found in unitcraft/format.py(으)로 실패한다. 같은 호출 가운데 첫 번째는 step 11에 나왔고, 규칙이 실행을 끝내기 전에 연속 횟수는 3에 이르렀다. 이 예제는 종료 방식과 멈추는 단계를 단언한다. 그래서 멈추는 지점을 옮기는 변경은 출력 결과를 슬쩍 바꾸는 대신 실행을 실패시킨다.

읽기와 편집을 번갈아 하는 모델은 이 규칙에 걸리지 않는다. 읽기가 나올 때마다 연속이 끊기기 때문이다. 다음 규칙은 그 경우를 위한 것이다.

이 규칙은 형식이 올바른 같은 호출이 바뀌지 않고 되돌아오는 경우를 다룬다. 깨진 응답은 다른 종류의 실패이며, 잘못된 호출이 모델이 읽을 수 있는 타입 지정 오류로 되돌아오는 곳은 도구 스키마이다.

작업 규칙: 호출은 도구 이름과 정렬된 인자로 비교하고, 같은 호출이 연속으로 세 번 나오면 실행을 끝낸다. 임곗값은 직접 확보한 트레이스에서 같은 호출이 연속으로 세 번 나왔는데도 진전이 있었던 경우를 확인한 뒤에만 올린다. 그런 다음 더 높인 값을 유지하기 전에 자신의 과제 집합에서 측정한다.

편집 간 진전 없음

읽기와 편집을 번갈아 하는 모델은 같은 호출을 연속으로 세 번 보내지 않는다. 따라서 실행이 아무 데도 이르지 못하더라도 반복 호출 규칙은 셀 대상이 없다. 이 경우에 맞는 신호는 테스트 개수다. 하네스는 편집할 때마다 스크래치 복사본에서 눈에 보이는 테스트, 즉 해당 사례 자체의 테스트 스위트를 실행하고, 그 결과로 만든 요약에서 8 failed, 22 passed과 같은 개수 줄을 보관한다. 모델은 이 실행을 보지 못한다. 하네스가 자체 판단을 위해 보관한다.

이는 Building effective agents의 지침이 요구하는 종류의 신호다. 이 지침은 에이전트가 각 단계에서 환경으로부터 기준 진실(ground truth)을 얻는 것이 중요하다고 말하며, 테스트 개수는 그런 기준 진실에 해당한다. 다만 이 지침은 2024년 12월 글에 담긴 의견이지 측정 결과가 아니다.

이 규칙은 개수를 바꾸지 못한 편집이 연속으로 몇 번 나왔는지 센다. 첫 번째 편집은 편집이 하나도 이루어지기 전의 개수와 비교한다. 개수를 바꾸는 편집이 나오면 이 횟수는 0으로 되돌아간다. 읽기는 이 횟수에 영향을 주지 않는다. 연속 두 번이 되면 실행은 no_progress로 끝난다. 실패한 편집은 파일을 그대로 두므로 개수도 그대로이고, 규칙은 이를 진전 없음으로 센다.

작업 세트 기록의 T-01을 두 번 실행해 보자. 이 사례는 도구 세트 v1을 쓰고 편집이 실패한다. 한 번은 규칙 없이, 한 번은 진전 없음 규칙을 편집 두 번으로 설정하고 실행한다. 각 실행이 어디서 끝나는지 읽어 보자.

no-progress-stops.py Python 3.12.15 · pydantic 2.14.3 통과
"""The recorded run of T-01 under the no-progress rule. Two edits in a row that leave the test counts where theywere end the run as no_progress. The counts come from the harness's own run of the visible tests after each edit."""from lib.case import load_tasksfrom lib.loop import EDITS, Stops, run_taskfrom lib.models import ReplayModelfrom lib.tools import V1from lib.trace import IdCountertask = load_tasks(only=["T-01"])[0]def replay(stops: Stops):    return run_task(ReplayModel("task-set", "T-01"), task, V1, max_steps=V1.step_cap, ids=IdCounter(), stops=stops)plain = replay(Stops())print("without the rule, ended:", plain.ended, "at step", plain.steps)run = replay(Stops(no_progress_limit=2))print("with the rule, ended:", run.ended, "at step", run.steps)edit_steps = [r["step"] for r in run.trace.records if r["tool"] in EDITS]print("edits that left the counts unchanged, steps:", " and ".join(str(step) for step in edit_steps[-2:]))print("counts after the last edit:", run.counts)print("last two steps:", *run.trace.lines()[-2:], sep="\n  ")assert run.ended == "no_progress" and run.steps == 5
출력python no-progress-stops.py
without the rule, ended: step_cap at step 16
with the rule, ended: no_progress at step 5
edits that left the counts unchanged, steps: 3 and 5
counts after the last edit: 8 failed, 22 passed
last two steps:
  step 4: read_file: 23 lines
  step 5: edit_file: error: old text not found in unitcraft/format.py

규칙이 없으면 실행은 step_cap at step 16로 끝난다. 규칙이 있으면 개수를 바꾸지 못한 두 번의 편집 가운데 두 번째에서 no_progress at step 5로 끝난다. 이 편집들은 3 and 5에 있다. 둘 다 old text not found로 실패했으므로 어느 쪽도 개수를 바꾸지 못했고, 개수는 8 failed, 22 passed에 머물렀다. 출력의 마지막 두 단계는 읽기와 두 번째 실패한 편집이다. 읽기는 두 편집 사이에 있지만 횟수를 되돌리지 않는다. 그래서 규칙은 기록상 붙어 있지 않은 편집에서도 작동할 수 있다.

이 규칙은 테스트 요약에서 한 줄, 즉 8 failed, 22 passed와 같은 개수 줄만 읽는다. 어떤 테스트가 실패했는지는 읽지 않는다. 그러므로 테스트 하나를 고치면서 다른 하나를 깨뜨려 개수가 같아지는 편집은 진전 없음으로 보인다. 파일을 비교하는 방법도 도움이 되지 않는다. 실패한 편집은 파일을 그대로 두지만, 파일을 실제로 바꾸는 편집도 개수를 같게 둘 수 있다. 하네스가 테스트 이름을 읽지 않고도 개수를 비교할 수 있기 때문에 개수를 택했다. 이 선택은 자신의 실행에서 확인해 보라. 실패 하나가 다른 실패로 바뀌는 경우가 있다면 중단으로 나타날 것이다.

이 실행은 편집이 두 번 실패하면 멈추지만, 세 번째 편집은 성공했을지도 모른다. 우리는 두 번을 택했으며, 이렇게 멈춘 실행이 계속했다면 얼마나 자주 성공했을지에 대해 이 책은 아무 주장도 하지 않는다. 작업 세트에서는 11개의 실행이 이렇게 끝났고, 점수의 규칙에 따르면 그중 어느 것도 완료된 것이 아니다.

실패한 편집은 도구 스키마가 다루는 실패다. 3장에서는 텍스트를 찾지 못한 편집이 무엇을 돌려주는지를 바꾼다. 모델이 같은 텍스트를 다시 보내는 대신 고칠 수 있도록 파일에서 가장 가까운 줄을 돌려주며, 이는 가장 가까운 줄을 알려 주는 편집 오류에서 볼 수 있다.

작업 규칙: 모델이 무엇을 바꿨다고 말하는지가 아니라, 하네스가 편집할 때마다 테스트에서 얻는 개수를 지켜본다. 개수를 바꾸지 못한 편집이 연속으로 두 번 나오면 실행을 멈춘다. 이를 no_progress로 기록하고, 멈출 때의 개수를 그 실행 옆에 남긴다.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Asking, stopping and counting the endings

Once a rule ends a run, nothing in the loop asks the person who gave the task what to do next.

Only ask_user asks. The model calls it with a question, the harness hands the question back, and no change is made. The stop rules work differently. A repeated_call or no_progress stop records the rule that fired and the call or the counts it stopped on, and the run is over. Turning such a stop into a question for a person is the handoff in subagents and handoffs. What a change may do without a person's yes is the gate in permission gates.

The last check in this chapter runs all 20 tasks twice, once as recorded and once with both rules, repeated calls and no progress. It prints counts only:

stop-rules-over-task-set.py Python 3.12.15 · pydantic 2.14.3 통과
"""The task-set recording's 20 runs, replayed as recorded and again with both stop rules. Counts only: which runs hitthe step cap, which rule ended the runs that stopped early, and whether any done task is cut short."""from collections import Counterfrom lib.case import load_tasksfrom lib.loop import Stops, run_taskfrom lib.models import ReplayModelfrom lib.tasks import scorefrom lib.tools import V1from lib.trace import IdCounterRULES = Stops(repeat_limit=3, no_progress_limit=2)def replay(stops: Stops) -> dict:    """Every task in file order, so the run IDs match the recording's. Maps task ID to (ended, steps, done)."""    ids, out = IdCounter(), {}    for task in load_tasks():        run = run_task(ReplayModel("task-set", task.id), task, V1, max_steps=V1.step_cap, ids=ids, stops=stops)        out[task.id] = (run.ended, run.steps, score(task, run))        run.close()    return outENDS = ("finish", "ask_user", "step_cap", "repeated_call", "no_progress", "no_tool_call")plain, ruled = replay(Stops()), replay(RULES)capped = sorted(t for t, (ended, _, _) in plain.items() if ended == "step_cap")ruled_ends = Counter(ended for ended, _, _ in ruled.values())done = sorted(t for t, (_, _, ok) in plain.items() if ok)print("task set step cap:", V1.step_cap)print("runs:", len(plain))print("step cap without the rules:", len(capped))print("step cap without the rules, tasks:", ", ".join(capped))print("step cap with the rules:", ruled_ends["step_cap"])print("ended early with the rules:", len([t for t in capped if ruled[t][0] != "step_cap"]))for ended in ENDS:    print(f"  {ended}: {ruled_ends[ended]}")print("done without the rules:", len(done))print("done without the rules, tasks:", ", ".join(done))print("done with the rules:", sum(1 for _, _, ok in ruled.values() if ok))print("done with the rules, by finish:", sum(1 for ended, _, ok in ruled.values() if ended == "finish" and ok))print("finish but not done, with the rules:", sum(1 for ended, _, ok in ruled.values() if ended == "finish" and not ok))print("done with the rules, by ask_user:", sum(1 for ended, _, ok in ruled.values() if ended == "ask_user" and ok))wrong = [t for t, (ended, _, ok) in plain.items() if ended == "ask_user" and not ok]print("ask_user but not done, without the rules:", len(wrong))print("of those, cut early with the rules:", len([t for t in wrong if ruled[t][0] != "ask_user"]))assert len(capped) == 7 and all(ruled[t][2] for t in done), "a done task must survive the rules"assert sum(ruled_ends.values()) == len(plain), "every run has one ending"
출력python stop-rules-over-task-set.py
task set step cap: 16
runs: 20
step cap without the rules: 7
step cap without the rules, tasks: T-01, T-02, T-06, T-10, T-11, T-13, T-16
step cap with the rules: 1
ended early with the rules: 6
  finish: 6
  ask_user: 1
  step_cap: 1
  repeated_call: 1
  no_progress: 11
  no_tool_call: 0
done without the rules: 5
done without the rules, tasks: T-04, T-05, T-09, T-14, T-18
done with the rules: 5
done with the rules, by finish: 4
finish but not done, with the rules: 2
done with the rules, by ask_user: 1
ask_user but not done, without the rules: 6
of those, cut early with the rules: 6

The rules cut stuck runs short without losing a done task. Without them, the budget ends 7 of the 20 runs; with them, only 1 still reaches it.

With the rules on, the most common end was no_progress, at 11 runs, and finish came next, at 6 runs.

Each done task still passes with the rules on, and the example checks it. Of the 5 done runs, 4 end with finish and pass their check, and 1 ends with the ask_user on T-18, which is the fifth. The other 2 finish runs fail their check, so they are not done.

Without the rules, 6 runs asked a question and were not done. With the rules, 6 of those runs ended earlier, and none of them asked. The one ask_user left with the rules on is T-18's, which the scorer counts as done; chapter 10 shows that it counts only through a word in a path. A stop that ends a run early doesn't make the run right. It ends the run before the wrong question is asked, and that run is still not done. The rules cut the waste; they can't tell a right question from a wrong one.

You can check the output yourself. The six endings with the rules on add up to the number of runs, as the lines of the output show, and the done count is the same with the rules and without them. If the done count ever moves, a rule has cut a run that was going to pass, and the rule is the thing to change. If a run in your own work ends stuck, read it in this order: the ended value, then the last few steps, then the first step where a call began to repeat. Those reads take less time than reading the whole transcript.

Working rule: Count each run by the ended value it recorded, and report the counts with the rules on and off, next to the done count. A stop can only turn a run into one that is not done, so when you change a rule, check that the done count holds before you keep the change.

이 장의 결정 사항

여기에 나오는 각 항목은 이 책이 고른 기본값이며, 어느 것도 법칙이 아니다. 작업 규칙은 기본값을 언제 바꿔야 하는지 알려 준다. 바꾸는 일은 먼저 자신의 작업 집합에서 해야 한다. 그래야 다른 사람이 그 변경에 의존하기 전에, 변경이 완료된 작업에 끼친 영향을 직접 셀 수 있다.

  • 중단 규칙은 선택 사항이며 루프에서 기본적으로 꺼져 있다. 중단 규칙이 없는 실행은 1장의 루프와 같은 요청을 보낸다.
  • 반복 호출은 같은 호출이 연속으로 세 번 나오는 경우이며, 도구 이름과 정렬된 인자를 기준으로 비교한다.
  • 진전 없음은 하네스의 테스트 집계를 바꾸지 못한 편집이 연속으로 두 번 나오는 경우이다. 첫 번째 편집은 어떤 편집도 하기 전의 집계와 비교한다.
  • 중단은 실행을 하나의 결과로 끝낸다. 어떤 중단 규칙도 사람에게 묻지 않으며, 인계는 하위 에이전트와 인계에서 다룬다.
  • 단계 예산은 형식이 잘못된 응답을 포함하여 모델 호출 횟수를 센다. 이 장은 단계 예산을 시간이나 토큰의 한도로 취급하지 않는다.
  • 여섯 가지 종료의 이름은 고정되어 있다. 관문은 6장에서 하나를 더한다.
  • 규칙과 그 집계를 밝히는 중단은 독자가 확인할 수 있는 중단이다. 예산만 밝히는 중단은 독자를 모든 단계로 다시 돌려보낸다.

이 판의 이 장

2026.11.2판예제 통과 2026년 11월 20이 장에서 4개 예제개 중 4개가 통과한다

영어판 2026.11.2판을 번역한 것이다.

이 절 인용

형식

각 형식은 이 번역이 따르는 영문 원서를 출처로 표기한다.

모든 형식은 이 판을 명시한다. 링크는 현재 판을 열며, 여기서 절의 제목은 본문이 마지막으로 바뀐 시점을 알려 준다. 접근 날짜와 검색 날짜는 이 자료를 여는 날짜다.

이 페이지의 내용

12장 중 2장: 작업이 끝났거나 막혔을 때 루프를 멈춘다

  1. 실행이 끝나는 방식
  2. 예산은 단계를 센다
  3. 같은 호출, 다시
  4. 편집 간 진전 없음
  5. Asking, stopping and counting the endings
  6. 이 장의 결정 사항

맨 위로 돌아가기전체 장