AIDive

Video-Paket

Drei Claude Code Subagent-Dateien und die Fold-Test-Eval, die eine vierte strich

7 Min. Lesezeit

TL;DR und Fazit

Anthropics Artikel über das Falten von Subagents in die Hauptschleife rät dazu, weniger davon zu nutzen, und die Videos dazu sagen "lösch deine Subagents". Der Artikel behält trotzdem drei Fälle und gibt dir für alles andere einen Test s1. Dieses Paket enthält die drei Dateien, die den Test bestehen (einen Recherche-Scout, einen schreibgeschützten Reviewer, einen isolierten Builder), die vierte Datei, die wir durch den Test geschickt haben (einen Test-Writer), und das Skript, das ihn ausgeführt hat.

  • Der Scout, der Reviewer und der Builder beantworten je einen Behalten-Fall, und jeder hat seinen Grund in seiner description stehen.
  • Der vierte Agent, ein Test-Writer, durchlief den Fold-Test: sechs Aufgaben, je zwei Läufe, einmal als Subagent und einmal in einen Skill gefaltet. In einen Skill gefaltet bestand er 12/12. Als Subagent bestand er 11/12, bei durchschnittlich 0.410 Dollar pro Lauf gegen 0.262 und 72 Sekunden gegen 36.
  • Der Test-Writer hat also seine Datei verloren. Die gefaltete Version schnitt nie schlechter ab.

Fazit: Behalte die drei Dateien und schicke jeden anderen Agenten durch den Fold-Test, bevor er eine Datei bekommt. Verzichte auf den Scout bei schnellem Nachschlagen, schicke den Builder nie an Code, den deine Hauptsession gerade bearbeitet, und lies die Liste des Unbelegten beim Reviewer so sorgfältig wie sein Urteil. Die Grenzen sind real: zwölf Läufe pro Seite an einem Repo, und der eine Fehlschlag des Subagents war ein Testbefehl, den unsere Projekteinstellungen nicht erlaubten. Führe es an deinem eigenen Repo aus.

Quellengestützte Synthese

Der Artikel behält Subagents für drei Fälle. Nutze sie, wenn eine einzelne Agentenschleife durch aufgeblähten Kontext messbar schlechter wird, wenn mehrere Aufgaben parallel mit frischen Kontextfenstern laufen, die verworfen werden können, oder wenn ein einzelner Agent Mühe hat, das richtige Tool zu wählen, oder auf widersprüchliche Anweisungen im System-Prompt trifft s1.

Der Fold-Back-Test. Baue eine kleine End-to-End-Eval, falte einen Subagent ein und behalte ihn nur als Subagent, wenn die gefaltete Version schlechter abschneidet, dann wiederhole s1. Der Artikel ist für Claude-Platform-Agenten geschrieben und spricht nicht über Claude Code Dateien, also wenden wir seinen Test per Analogie an s1.

Wie du aufteilst, wenn du einen behältst. Teile nach Kontext: Gib jedem Subagent ein Stück Arbeit, das wenig vom Rest des Systems braucht, und lass ihn ein kompaktes Ergebnis zurückgeben s1. Deshalb trägt der Scout einen Rückgabevertrag und der Reviewer eine Antwortform.

Eine Subagent-Datei ist eine Markdown-Datei mit YAML-Frontmatter. Nur name und description sind Pflicht, und tools erbt alle für Subagents verfügbaren Tools, wenn es fehlt s2. Ein schreibgeschützter Agent muss seine Tools also ausdrücklich auflisten. Damit ein Reviewer keine Helfer startet, lass Agent aus seiner Tool-Liste weg oder trage es in disallowedTools ein s2.

Du schreibst die Dateien von Hand. Claude Code 2.1.198 hat den Assistenten /agents entfernt: Bitte Claude, Subagents anzulegen oder zu verwalten, oder bearbeite .claude/agents/ direkt. Außerdem laufen Subagents seitdem standardmäßig im Hintergrund s24 s3.

maxTurns und isolation: worktree leisten, was der Builder braucht. Wenn der Subagent das Limit maxTurns erreicht, gibt Claude Code seine Ausgabe als teilweise markiert zurück s2. Die Worktree-Isolation gibt dem Subagent eine isolierte Kopie des Repositorys, standardmäßig von deinem Standard-Branch abgezweigt statt vom HEAD der übergeordneten Session, und der Worktree wird aufgeräumt, wenn der Subagent nichts ändert s2. Version 2.1.295 behob, dass Subagents in ihrem eigenen verknüpften Worktree den Git-Branch der übergeordneten Session angezeigt bekamen s3. Wir haben mit 2.1.294 gearbeitet.

Lesen fächert auf, Schreiben bleibt einzeln. Fächere für Lesezugriffe auf, bleibe bei Schreibzugriffen einzeln s8. Deshalb enthält das Paket einen Builder und nie eine Mannschaft.

Auffächern kostet Tokens und findet bei gewöhnlichen Suchen nichts mehr. Multi-Agent-Setups verbrauchen typischerweise 3-10x mehr Tokens als Ansätze mit einem einzelnen Agenten für gleichwertige Aufgaben s4. In einem Benchmark mit 288 Läufen lag der Recall in jeder Bedingung bei 97-100%, und die Kosten pro Lauf stiegen bei Haiku 5.5 um 74% bis 116% und bei Opus 5.5 um 143% bis 221% s5. Der Scout lohnt sich, wenn das Lesen groß ist und deine Session danach noch Arbeit hat.

Ein Reviewer braucht Belege, sonst erfindet er Befunde. In einem Issue markierte ein Reviewer korrekten Code, weil ihm Versionsinformationen fehlten, und der Hauptagent gab den Befund ungeprüft weiter s12. Unsere Reviewer-Datei lehnt deshalb jeden Befund ohne zitierte Zeile ab. Ein Reviewer, der am Ende alles durchwinkt, hat ebenfalls aufgehört zu arbeiten s11, also prüfe ab und zu, ob deiner noch etwas findet.

Agent-Ordner verrotten. Ein Entwickler berichtete, dass 16 importierte Agenten in zwei Wochen nie gestartet wurden s10. Ein Hintergrund-Subagent kann zudem an einer Berechtigungsabfrage hängen bleiben, wie das offene Issue zu Subagents mit Worktree-Isolation zeigt s13.

Anthropics eigenes Recherchesystem ist ein Auffächern. Es zeigt, wo sich paralleles Lesen lohnt s14. Die meisten Coding-Aufgaben haben weniger wirklich parallelisierbare Teile als Recherche.

Code

Installationshinweis: Lege die Agent-Dateien in .claude/agents/ deines Projekts ab. Sie werden wenige Sekunden nach dem Speichern erkannt, außer das Verzeichnis agents existierte beim Start der Session nicht, dann starte neu s2. Die Konventionszeile des Reviewers (Geld in ganzzahligen Cent, Domänenfunktionen verändern nie, Fehler werden als ValidationError, NotFoundError oder ConflictError geworfen) beschreibt unsere Beispiel-Rechnungs-API: Ersetze sie durch deine eigenen Konventionen.

Der Scout deckt den Fall des aufgeblähten Kontexts ab. Er hat nur Read, Grep und Glob, läuft auf dem günstigen Modell haiku und gibt höchstens 12 Zeilen zurück: die Antwort, den Beleg als path:line und was er nicht gefunden hat. Lege ihn als .claude/agents/scout.md ab und bitte um einen Scout pro unabhängiger Frage, parallel.

scout.md

---
name: scout
description: Read-only researcher for one question about this codebase that needs many files read but only a short answer back. Use proactively, one scout per independent question, in parallel.
tools: Read, Grep, Glob
model: haiku
---
You answer one question about this codebase. Read what you need. Never edit anything.

Return at most 12 lines:
1. The answer, in plain words, first.
2. The proof: the files and lines that show it, as path:line.
3. What you did not find or are not sure of.

No code block longer than 5 lines.

scout.md on GitHub

Der Reviewer deckt den Fall der Prüfung mit frischem Blick ab. Nur Read, Grep und Glob, kein Agent, er kann also weder bearbeiten noch Helfer starten. Gib ihm die Spezifikation und den Diff (git diff main...<branch>) und prüfe jeden Befund selbst, bevor du handelst. Lege ihn als .claude/agents/reviewer.md ab.

reviewer.md

---
name: reviewer
description: Read-only code reviewer. Use after a change is built, with the spec and the diff in the prompt. Returns a verdict with file:line evidence. Never edits.
tools: Read, Grep, Glob
model: sonnet
---
You review one change against its spec. The spec and the diff are in your prompt; read the surrounding code you need to judge them.

Look for what breaks: wrong behaviour against the spec, an edge case the code or its tests miss, a broken convention of this repo (money in integer cents, domain functions never mutate, errors thrown as ValidationError, NotFoundError or ConflictError).

Answer in this shape, nothing else:
VERDICT: PASS or FAIL
FINDINGS (most serious first, at most 5):
- [high|medium|low] path:line - what breaks, and the line that proves it, quoted
UNVERIFIED:
- anything you suspect but could not prove from the code

No style remarks. No finding without a quoted line.

reviewer.md on GitHub

Der Builder deckt den Fall der getrennten Komponente ab. isolation: worktree gibt ihm eine eigene Kopie des Repos und einen eigenen Branch, und maxTurns: 40 hält einen Builder an, der sich im Kreis dreht. Gib ihm ein in sich geschlossenes Stück, während du weiterarbeitest, und merge, nachdem der Reviewer es durchgelassen hat. Lege ihn als .claude/agents/builder.md ab und ändere die Install- und Testbefehle auf deine.

builder.md

---
name: builder
description: Builds one self-contained component with a clean interface, tests included, in its own git worktree. Use when a separate piece can be built while the main session keeps working. Never for changes to code the main session is editing.
isolation: worktree
maxTurns: 40
model: inherit
---
You build exactly the component in your prompt, in this worktree, and nothing else.

1. Run `git branch --show-current` and `git rev-parse --show-toplevel` and report both.
2. If node_modules is missing, run `pnpm install --frozen-lockfile`.
3. Write the code and its tests. Follow the conventions in README.md.
4. Run `pnpm test` and `pnpm typecheck` until both are green.
5. Commit on your branch with a one-line message.

Report in at most 10 lines: branch, files changed, test count before and after, anything you did not do.

builder.md on GitHub

Der Test-Writer ist die vierte Datei, die der Fold-Test entfernt hat. Sie liegt hier, damit du denselben Test darauf ausführen oder sie als Vorlage für den Agenten nutzen kannst, den du gerade hinzufügen willst. Wenn du sie behältst, gehört sie nach .claude/agents/test-writer.md.

test-writer.md

---
name: test-writer
description: Writes vitest tests for one module of this repo. Use proactively when the user asks to add or improve tests for a file or module.
tools: Read, Grep, Glob, Edit, Write, Bash
model: inherit
---
You write tests for exactly one module.

1. Read the module and the code that calls it. Read the existing test file for it, if any.
2. Add the missing cases to the test file under test/ (create it if none exists): boundaries, empty and invalid input, every branch, and anything the code promises in a comment.
3. Never edit files under src/. If a test reveals a bug, keep the test, mark it `it.fails`, and say so.
4. Run `pnpm test` until the suite is green.

Report in at most 6 lines: the test file, the cases added, the test count before and after.

test-writer.md on GitHub

Die Projekteinstellungen, die für die Läufe galten. Der Builder und der Test-Writer führen nur aus, was die Einstellungen erlauben, daher kann eine Allow-Liste, der ein Befehl fehlt, dich einen Lauf kosten: So kam unser einziger Subagent-Fehlschlag zustande. Füge die Zeilen, die du brauchst, in .claude/settings.json ein.

ledgerly-settings.json

{
  "permissions": {
    "allow": [
      "Bash(pnpm test)", "Bash(pnpm test:*)", "Bash(pnpm typecheck)", "Bash(pnpm install:*)",
      "Bash(npx vitest:*)", "Bash(git status:*)", "Bash(git diff:*)", "Bash(git log:*)",
      "Bash(git add:*)", "Bash(git commit:*)", "Bash(git branch:*)", "Bash(git rev-parse:*)", "Bash(git worktree list)",
      "Edit", "Write"
    ]
  }
}

ledgerly-settings.json on GitHub

Das Fold-Test-Harness, in vier Dateien. run-one.sh führt eine Aufgabe als Subagent oder in einen Skill gefaltet aus, mit demselben Nutzer-Prompt. score.py wendet die vorab festgelegte Bestehensregel an: Suite grün, keine Quelldatei geändert und der eingebaute Bug gefunden. mutations.py enthält pro Modul einen eingebauten Bug. jobs.txt listet die sechs Aufgaben mit je zwei Läufen, abwechselnd nach Variante. Die Pfade zeigen auf unseren Scratch-Ordner und unsere Beispielmodule, ändere also den Wurzelpfad und die Mutationen passend zu deinem Repo, bevor du sie ausführst.

run-one.sh

#!/bin/bash
# One fold-test run: run-one.sh <variant agent|skill> <task> <n>
# Copies ledgerly, sets up the variant, sends the same user prompt, scores the result.
set -u
V=$1; T=$2; N=$3
ROOT=/private/tmp/subagents-bench
W=$ROOT/eval/runs/$V-$T-$N
rm -rf "$W"; mkdir -p "$W"; cp -R "$ROOT/ledgerly/." "$W/"
cd "$W"
if [ "$V" = skill ]; then
  # Fold: the subagent's prompt becomes a skill in the main loop; the agent file moves aside
  mkdir -p .claude/skills/test-writer
  BODY=$(awk 'f>=2{print} /^---$/{f++}' .claude/agents/test-writer.md)
  { printf -- '---\nname: test-writer\ndescription: Write vitest tests for one module of this repo. Use when the user asks to add or improve tests for a file or module.\n---\n'; printf '%s\n' "$BODY"; } > .claude/skills/test-writer/SKILL.md
  git mv .claude/agents/test-writer.md .claude/test-writer.agent.md.aside
  git add -A .claude && git commit -qm "eval: fold test-writer into a skill"
fi
FILE=$(python3 -c "import sys;sys.path.insert(0,'$ROOT/eval');from mutations import MUTATIONS;print(MUTATIONS['$T'][0])")
START=$(date +%s)
claude -p "Add tests for $FILE." --model opus --setting-sources project,local \
  --output-format stream-json --verbose --permission-mode acceptEdits > run.jsonl 2> run.err
END=$(date +%s)
# Score
SRC_CHANGED=$(git status --porcelain -- src | wc -l | tr -d ' ')
npx vitest run > after.txt 2>&1 && GREEN=1 || GREEN=0
TESTS=$(grep -Eo 'Tests +[0-9]+ passed' after.txt | grep -Eo '[0-9]+' | head -1)
python3 - "$W" "$T" <<'PY'
import sys; sys.path.insert(0, "/private/tmp/subagents-bench/eval")
from mutations import MUTATIONS
w, t = sys.argv[1], sys.argv[2]; f, old, new = MUTATIONS[t]
p = f"{w}/{f}"; s = open(p).read(); open(p, "w").write(s.replace(old, new))
PY
npx vitest run > mutant.txt 2>&1 && KILLED=0 || KILLED=1
git checkout -q -- "$FILE"
python3 "$ROOT/eval/score.py" "$W" "$V" "$T" "$N" "$SRC_CHANGED" "$GREEN" "${TESTS:-0}" "$KILLED" "$((END-START))" >> "$ROOT/eval/results.jsonl"
tail -1 "$ROOT/eval/results.jsonl"

run-one.sh on GitHub

score.py

# Parse one run's stream-json and write a result row
import json, sys
w, v, t, n, src_changed, green, tests, killed, wall = sys.argv[1:]
delegated = skill = False
result = {}
for line in open(f"{w}/run.jsonl"):
    try: e = json.loads(line)
    except Exception: continue
    if e.get("type") == "assistant":
        for b in e["message"].get("content", []):
            if b.get("type") == "tool_use":
                i = b.get("input", {})
                if b["name"] in ("Agent", "Task") and i.get("subagent_type") == "test-writer": delegated = True
                if b["name"] == "Skill" and "test-writer" in json.dumps(i): skill = True
    if e.get("type") == "result": result = e
passed = int(src_changed) == 0 and green == "1" and killed == "1"
print(json.dumps({
    "variant": v, "task": t, "run": int(n),
    "invoked": delegated if v == "agent" else skill,
    "pass": passed, "green": green == "1", "srcChanged": int(src_changed), "killed": killed == "1",
    "tests": int(tests), "wallSec": int(wall),
    "costUsd": result.get("total_cost_usd"), "durationMs": result.get("duration_ms"), "turns": result.get("num_turns"),
    "usage": result.get("usage"), "modelUsage": result.get("modelUsage"), "isError": result.get("is_error"),
}))

score.py on GitHub

mutations.py

# One planted mutation per golden task: (task id, file, old, new)
MUTATIONS = {
  "money":      ("src/domain/money.ts", "if (value < min) {", "if (value <= min) {"),
  "customer":   ("src/domain/customer.ts", "name.trim() === \"\"", "name === \"\""),
  "invoice":    ("src/domain/invoice.ts", 'invoice.dueDate < now.toISOString()', 'invoice.dueDate <= now.toISOString()'),
  "validation": ("src/domain/validation.ts", "quantity < 1", "quantity < 0"),
  "migrations": ("src/store/migrations.ts", "{ customer: 0, invoice: 0, invoiceNumber: 0 }", "{ customer: 0, invoice: 0, invoiceNumber: 1 }"),
  "router":     ("src/http/router.ts", "decodeURIComponent(m[i + 1])", "m[i + 1]"),
}

mutations.py on GitHub

jobs.txt

skill money 1
agent customer 1
skill customer 1
agent invoice 1
skill invoice 1
agent validation 1
skill validation 1
agent migrations 1
skill migrations 1
agent router 1
skill router 1
agent money 2
skill money 2
agent customer 2
skill customer 2
agent invoice 2
skill invoice 2
agent validation 2
skill validation 2
agent migrations 2
skill migrations 2
agent router 2
skill router 2

jobs.txt on GitHub

baseline-kill.sh prüft zuerst die Mutationen: Jede muss die bestehende Suite scheitern lassen, oder überleben, wenn sie es soll, bevor du der Eval vertraust.

baseline-kill.sh

#!/bin/bash
# For each mutation: apply on a scratch copy of ledgerly, run the suite, report killed/survived
set -u
SRC=/private/tmp/subagents-bench/ledgerly
for t in money customer invoice validation migrations router; do
  W=$(mktemp -d /private/tmp/subagents-bench/eval/mut-XXXX); cp -R "$SRC/." "$W/"
  python3 - "$W" "$t" <<'PY'
import sys; sys.path.insert(0, "/private/tmp/subagents-bench/eval")
from mutations import MUTATIONS
w, t = sys.argv[1], sys.argv[2]
f, old, new = MUTATIONS[t]
p = f"{w}/{f}"; s = open(p).read()
assert s.count(old) == 1, (t, s.count(old)); open(p, "w").write(s.replace(old, new))
PY
  (cd "$W" && npx vitest run >/dev/null 2>&1) && echo "$t survived" || echo "$t killed"
  rm -rf "$W"
done

baseline-kill.sh on GitHub

Das machst du am Montag

  • Führe claude --version aus und beachte, dass /agents seit 2.1.198 nur noch ein Verweis ist: Du legst Agent-Dateien an, indem du .claude/agents/ bearbeitest oder Claude bittest s24.
  • Liste die Agent-Dateien auf, die du heute hast, und schreibe den Behalten-Grund jeder einzelnen in einem Satz auf. Wenn du das nicht kannst, ist sie ein Kandidat zum Falten in einen Skill.
  • Kopiere scout.md und reviewer.md nach .claude/agents/ und passe die Konventionszeile des Reviewers an dein Repo an.
  • Kopiere builder.md, prüfe, dass deine Allow-Liste seine Test- und Typecheck-Befehle abdeckt, und gib ihm ein in sich geschlossenes Stück Arbeit auf einem Branch.
  • Erstelle ein Golden Set aus 6 Prompts für den Agenten, an dem du zweifelst, jeweils mit einer Bestehensregel, die du vor dem Lauf festlegst: grüne Suite, keine Quelldatei geändert, ein eingebauter Bug gefunden.
  • Führe baseline-kill.sh (angepasst) aus, um zu belegen, dass jeder eingebaute Bug die aktuelle Suite scheitern lässt.
  • Führe jede Aufgabe zweimal als Subagent aus, schiebe die Agent-Datei beiseite, lege dieselben Anweisungen in einen Skill, führe jede Aufgabe noch zweimal aus und lies, welche Aufgaben gekippt sind, nicht nur den Score.
  • Behalte die Agent-Datei nur, wenn der Skill schlechter abschneidet. Sonst lösche sie.

Messwerte

Die Läufe fanden mit Claude Code 2.1.294 und Opus 5.5 am 2026-11-08 statt. Sie sind klein: zwölf Läufe pro Seite an einem Repo für den Fold-Test, zwei Läufe pro Seite für den Scout.

Fold-Test: Test-Writer, 6 Aufgaben x 2 Läufe x 2 Varianten

Variante Aufgerufen Bestanden Ø Kosten $ Ø Laufzeit s
agent 12/12 11/12 0.410 72
skill 12/12 12/12 0.262 36

Der einzige Fehlschlag: agent/router/2 ließ einen roten Test in test/router.test.ts zurück ("matches the root path": expected null not to be null). Jeder Lauf erkannte die eingebaute Mutation seines Moduls, und kein Lauf änderte src/.

Scout, gemessen an der Hauptsession (mainCtx ist die Kontextgröße der Hauptsession, spawns die Zahl der gestarteten Scouts, durS die Dauer in Sekunden)

Lauf mainCtx spawns Kosten $ durS turns
audit-inline-1 45868 0 0.457 55 15
audit-inline-2 47476 0 0.433 47 12
audit-scout-1 30505 3 0.267 17 1
audit-scout-2 33937 3 0.344 25 3
inline-1 32294 0 0.273 29 7
inline-2 33345 0 0.272 36 10
scout-1 28966 3 0.223 18 1
scout-2 30390 3 0.257 20 2

Die "audit"-Zeilen sind das große Lesen (wie jede eingebaute Middleware eines großen quelloffenen Frameworks eine Anfrage ablehnt). Die übrigen Zeilen sind drei kleine Fragen. Bei den kleinen Fragen sparte der Scout fast nichts. Die Scouts liefen auf haiku.

Weiterführend

Agent Teams sind ein anderer Mechanismus. Teams sind Sessions, die einander Nachrichten schicken, hinter einem experimentellen Flag, und nichts in diesem Paket braucht sie s3.

Auffächern kostet mehr als ein Chat. Anthropics eigenes Recherchesystem misst seine Multi-Agent-Kosten gegen einen Chat, nicht gegen einen einzelnen Agenten, lies diese Zahl also nicht als Subagents gegen eine Schleife s14. Unser Vergleich gegen einen einzelnen Agenten ist die Scout-Tabelle oben.

Subagent gegen Skill, in einer Zeile. Ein Subagent startet mit frischem, isoliertem Kontext; ein Skill läuft in deiner Hauptunterhaltung, in der die Session das Repo schon kennt. Deshalb war der gefaltete Test-Writer schneller.

Forks und Fortsetzen. Ein Fork erbt die ganze Unterhaltung, statt frisch zu starten, und ein angehaltener Subagent kann mit seinem vollen Verlauf fortgesetzt werden. Beides haben wir nicht getestet; lies die Subagent-Doku, bevor du dich darauf verlässt s2.

Mehrere Builder. Parallele Builder, die gleichzeitig schreiben, lagen außerhalb des Umfangs. Die Regel für den Anfang ist "Lesen fächert auf, Schreiben bleibt einzeln" s8.

Persona-Agenten. Architekt, Product Manager und andere Organigramm-Agenten sind das, was der Test entfernt. Anthropics Artikel warnt, dass die Agentenarchitektur zur Kopie des Organigramms wird s1.

FAQ

Spart der Scout immer Kontext? Nein. Bei unseren drei kleinen Fragen sparte er fast nichts, und das Auffächern bei gewöhnlichen Suchen fand nichts mehr bei höheren Kosten s5. Beim großen Lesen lohnte er sich, dort blieb die Hauptsession kleiner.

Warum hat der Reviewer kein Edit oder Write? Damit er nicht beheben kann, was er findet, und das Weglassen von Agent verhindert, dass er Helfer startet s2. Wenn du tools weglässt, hätte er alle Tools, weil ein fehlendes tools sie alle erbt s2.

Der Worktree meines Builders enthielt meine nicht committete Arbeit nicht. Ist das ein Bug? Nein. Der Worktree wird standardmäßig von deinem Standard-Branch abgezweigt, nicht von dem Stand, auf dem du bist s2. Committe oder merge zuerst, was der Builder braucht.

Der Test-Writer hat an eurem Repo verloren. Verliert er auch an meinem? Vielleicht nicht. Wir haben zwölf Läufe pro Seite an einem kleinen Repo ausgeführt, und der eine Fehlschlag des Subagents war ein Testbefehl, den unsere Einstellungen nicht erlaubten. Führe das Harness an deinem aus und lies jeden Lauf, der kippt, wie es der Artikel empfiehlt s1.

Kann ich den Reviewer warten lassen, statt im Hintergrund zu laufen? Subagents laufen seit 2.1.198 standardmäßig im Hintergrund s24. Die Doku beschreibt, wie du Claude bittest, auf seinen Bericht zu warten, und eine Einstellung, die es warten lässt; prüfe die Subagent-Doku für deine Version s2.

Dateien