TL;DR और निष्कर्ष
Anthropic का article, जो subagents को main loop में fold करने के बारे में है, कहता है कि इन्हें कम इस्तेमाल करो, और उस पर बने videos कहते हैं "अपने subagents delete कर दो"। Article फिर भी तीन मामले रखता है और बाकी सबके लिए आपको एक test देता है s1। यह pack वे तीन files हैं जो उस test को पास करती हैं (एक research scout, एक read-only reviewer, एक isolated builder), चौथी file जिसे हमने test से गुज़ारा (एक test writer), और वह script जिसने उसे चलाया।
- Scout, reviewer और builder हर एक एक keep-case का जवाब देते हैं, और हर एक का कारण उसकी
descriptionमें लिखा है। - चौथा agent, एक test writer, fold test से गुज़रा: छह tasks, हर एक के दो runs, एक बार subagent के रूप में और एक बार skill में fold करके। Skill में fold करने पर उसने 12/12 पास किए। Subagent के रूप में 11/12 पास हुए, औसतन प्रति run 0.410 डॉलर के मुकाबले 0.262 डॉलर पर, और 72 सेकंड के मुकाबले 36 सेकंड।
- तो test writer की file हट गई। Folded version कभी बदतर score नहीं लाया।
निष्कर्ष: तीनों files रखें, और हर दूसरे agent को file मिलने से पहले fold test से गुज़ारें। झटपट lookups के लिए scout छोड़ दें, builder को कभी ऐसे code में न भेजें जिसे आपका main session edit कर रहा है, और reviewer की "unverified" सूची को उतने ही ध्यान से पढ़ें जितने ध्यान से उसके verdict को। सीमाएँ असली हैं: एक repo पर हर तरफ़ बारह runs, और subagent की एकमात्र चूक ऐसा test command थी जिसकी हमारे project settings ने इजाज़त नहीं दी थी। इसे अपने repo पर चलाएं।
स्रोतों वाला सार
Article subagents को तीन मामलों में रखता है। इन्हें तब इस्तेमाल करें जब एक अकेला agent loop context bloat से measurable performance degradation झेले, जब कई tasks fresh context windows के साथ parallel चलें जिन्हें फेंका जा सके, या जब एक अकेला agent सही tool चुनने में जूझे या system prompt में टकराते instructions का सामना करे s1।
Fold-back test। एक छोटा end-to-end eval बनाओ, एक subagent को fold करो, और उसे subagent के रूप में तभी रखो जब folded version का score बदतर आए, फिर यही दोहराओ s1। Article Claude Platform के agents के लिए लिखा गया है और Claude Code की files की बात नहीं करता, इसलिए हम उसका test सादृश्य से लगाते हैं s1।
एक रखना हो तो बँटवारा कैसे करें। Context के हिसाब से बाँटें: हर subagent को काम का ऐसा हिस्सा दें जिसे बाकी system से कम चीज़ें चाहिए, और उससे एक compact नतीजा वापस करवाएं s1। इसीलिए scout के पास return contract है और reviewer के पास answer shape।
Subagent file YAML frontmatter वाली Markdown file है। सिर्फ़ name और description ज़रूरी हैं, और tools छोड़ने पर subagents को उपलब्ध हर tool inherit हो जाता है s2। इसलिए read-only agent को अपने tools साफ़ लिखने होंगे। Reviewer को helpers शुरू करने से रोकने के लिए उसकी tools सूची में से Agent हटा दें या उसे disallowedTools में जोड़ दें s2।
Files आप हाथ से लिखते हैं। Claude Code 2.1.198 ने /agents wizard हटा दिया: Claude से subagents बनाने या सँभालने को कहें, या सीधे .claude/agents/ edit करें। उसी ने subagents को default रूप से background में चलाना भी शुरू किया s24 s3।
maxTurns और isolation: worktree वही करते हैं जो builder को चाहिए। जब subagent maxTurns की सीमा पर पहुँचता है, तो Claude Code उसका output partial चिह्नित करके लौटाता है s2। Worktree isolation subagent को repo की एक अलग copy देता है, जो default रूप से आपकी default branch से बनती है, parent session के HEAD से नहीं, और अगर subagent कुछ नहीं बदलता तो worktree साफ़ कर दिया जाता है s2। Version 2.1.295 ने उस bug को ठीक किया जिसमें अपने linked worktree में चल रहे subagents को parent session की git branch दिखती थी s3। हमने 2.1.294 पर चलाया।
पढ़ना fan out होता है, लिखना अकेला रहता है। पढ़ने के लिए fan out करें, लिखने के लिए अकेले रहें s8। इसीलिए pack में एक builder है और कभी कोई दल नहीं।
Fan-out में tokens लगते हैं, और आम searches पर कुछ ज़्यादा नहीं मिलता। Multi-agent setups आमतौर पर बराबर के tasks के लिए single-agent तरीकों से 3-10x ज़्यादा tokens इस्तेमाल करते हैं s4। 288 runs के एक benchmark में हर condition में recall 97-100% रहा, और प्रति run cost Haiku 5.5 पर 74% से 116% तक और Opus 5.5 पर 143% से 221% तक बढ़ी s5। Scout तब फ़ायदा देता है जब पढ़ना बड़ा हो और उसके बाद आपके session के पास और काम हो।
Reviewer को सबूत चाहिए, वरना वह findings गढ़ता है। एक issue में, एक reviewer ने सही code को इसलिए गलत बताया क्योंकि उसके पास version की जानकारी नहीं थी, और main agent ने उस finding को बिना जाँचे आगे बढ़ा दिया s12। इसलिए हमारी reviewer file quoted line के बिना कोई finding नहीं मानती। जो reviewer आखिर में सब कुछ approve करने लगे, उसने भी काम करना बंद कर दिया है s11, इसलिए बीच-बीच में जाँचते रहें कि आपका अब भी कुछ पकड़ता है।
Agent folders सड़ जाते हैं। एक developer ने बताया कि import किए गए 16 agents दो हफ़्तों में कभी चले ही नहीं s10। Background subagent permission prompt पर अटक भी सकता है, जैसा worktree-isolated subagents पर खुला issue दिखाता है s13।
Anthropic का अपना research system एक fan-out है। यह दिखाता है कि parallel पढ़ना कहाँ फ़ायदा देता है s14। ज़्यादातर coding tasks में research के मुकाबले सच में parallelizable हिस्से कम होते हैं।
Code
Install note: agent files को अपने project के .claude/agents/ में रखें। Save करने के कुछ सेकंड के भीतर वे उठा ली जाती हैं, सिवाय तब जब session शुरू होते समय agents directory मौजूद नहीं थी, उस हाल में restart करें s2। Reviewer की conventions line (पैसा integer cents में, domain functions कभी mutate नहीं करते, errors ValidationError, NotFoundError या ConflictError के रूप में throw होते हैं) हमारी sample invoicing API का वर्णन करती है: उसे अपनी conventions से बदल दें।
Scout context-bloat वाले मामले का जवाब है। इसके पास सिर्फ़ Read, Grep और Glob हैं, यह सस्ते haiku model पर चलता है, और ज़्यादा से ज़्यादा 12 lines लौटाता है: जवाब, path:line के रूप में सबूत, और जो उसे नहीं मिला। इसे .claude/agents/scout.md के रूप में डालें और हर स्वतंत्र सवाल के लिए एक scout माँगें, 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.
Reviewer fresh-eyes वाली verification का जवाब है। सिर्फ़ Read, Grep और Glob, Agent नहीं, इसलिए यह न edit कर सकता है न spawn। इसे spec और diff (git diff main...<branch>) दें, और हर finding पर अमल करने से पहले खुद जाँचें। इसे .claude/agents/reviewer.md के रूप में डालें।
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.
Builder अलग component वाले मामले का जवाब है। isolation: worktree इसे repo की अपनी copy और branch देता है, और maxTurns: 40 गोल-गोल घूमते builder को रोक देता है। इसे एक अपने आप में पूरा हिस्सा दें और खुद काम करते रहें, फिर reviewer के पास करने के बाद merge करें। इसे .claude/agents/builder.md के रूप में डालें और install और test commands अपने वाले से बदल दें।
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.
Test writer चौथी file है, जिसे fold test ने हटा दिया। यह यहाँ इसलिए है कि आप उस पर वही test चला सकें, या इसे उस agent के template की तरह इस्तेमाल करें जिसे आप जोड़ने वाले हैं। अगर आप इसे रखते हैं, तो यह .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.
Runs में इस्तेमाल हुई project settings। Builder और test writer सिर्फ़ वही चलाते हैं जो settings इजाज़त देती हैं, इसलिए जिस allow list में कोई command छूट जाए वह आपको एक run की कीमत चुकवा सकती है: हमारी एकमात्र subagent चूक ऐसे ही हुई। जो lines चाहिए उन्हें .claude/settings.json में merge करें।
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
Fold-test harness, चार files में। run-one.sh एक task को subagent के रूप में या skill में fold करके चलाता है, उसी user prompt के साथ। score.py पहले से तय pass rule लगाता है: suite green, कोई source file नहीं बदली, और planted bug पकड़ा गया। mutations.py में हर module के लिए एक planted bug है। jobs.txt छह tasks की सूची है, हर एक के दो runs, variants बारी-बारी से। Paths हमारे scratch folder और हमारे sample modules की ओर इशारा करते हैं, इसलिए चलाने से पहले root path और mutations को अपने repo के हिसाब से बदलें।
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"
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"),
}))
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]"),
}
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
baseline-kill.sh पहले mutations जाँचता है: eval पर भरोसा करने से पहले हर mutation को मौजूदा suite को fail करवाना चाहिए, या जहाँ ऐसा होना चाहिए वहाँ बच निकलना चाहिए।
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
सोमवार को यह करें
-
claude --versionचलाएं, और ध्यान रखें कि 2.1.198 से/agentsबस एक pointer है: आप agent files.claude/agents/को edit करके या Claude से कहकर बनाते हैं s24। - आज आपके पास जो agent files हैं उनकी सूची बनाएं, और हर एक का keep-reason एक वाक्य में लिखें। अगर नहीं लिख सकते, तो वह skill में fold करने का उम्मीदवार है।
-
scout.mdऔरreviewer.mdको.claude/agents/में copy करें, और reviewer की conventions line को अपने repo के हिसाब से ढालें। -
builder.mdcopy करें, जाँचें कि आपकी allow list उसके test और typecheck commands को कवर करती है, और उसे एक branch पर एक अपने आप में पूरा काम दें। - जिस agent पर आपको शक है उसके लिए 6 prompts का golden set बनाएं, हर एक के साथ ऐसा pass rule जिसे आप चलाने से पहले तय कर लें: green suite, कोई source file नहीं बदली, एक planted bug पकड़ा गया।
-
baseline-kill.sh(अपने हिसाब से ढालकर) चलाएं ताकि साबित हो कि हर planted bug मौजूदा suite को fail करवाता है। - हर task को subagent के रूप में दो बार चलाएं, agent file को किनारे हटाएं, वही instructions एक skill में डालें, हर task फिर दो बार चलाएं, और पढ़ें कि कौन से tasks पलटे, सिर्फ़ score नहीं।
- Agent file को तभी रखें जब skill का score बदतर आए। वरना उसे delete कर दें।
नापे गए नतीजे
Runs 2026-11-08 को Claude Code 2.1.294 और Opus 5.5 पर हुए। वे छोटे हैं: fold test के लिए एक repo पर हर तरफ़ बारह runs, scout के लिए हर तरफ़ दो runs।
Fold test: test writer, 6 tasks x 2 runs x 2 variants
| Variant | Invoke हुआ | Pass | औसत cost $ | औसत wall s |
|---|---|---|---|---|
| agent | 12/12 | 11/12 | 0.410 | 72 |
| skill | 12/12 | 12/12 | 0.262 | 36 |
एकमात्र failure: agent/router/2 ने test/router.test.ts में एक red test छोड़ा ("matches the root path": expected null not to be null)। हर run ने अपने module का planted mutation मारा, और किसी run ने src/ edit नहीं किया।
Scout, main session पर नापा गया (mainCtx main session के context का आकार है, spawns शुरू किए गए scouts की संख्या, durS सेकंड में अवधि)
| Run | mainCtx | spawns | cost $ | 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 |
"audit" rows बड़ा पढ़ना हैं (एक बड़े open source framework का हर built-in middleware किसी request को कैसे reject करता है)। बाकी rows तीन छोटे सवाल हैं। छोटे सवालों पर scout ने लगभग कुछ नहीं बचाया। Scouts haiku पर चले।
आगे के लिए
Agent Teams एक अलग mechanism हैं। Teams वे sessions हैं जो एक-दूसरे को message करते हैं, एक experimental flag के पीछे, और इस pack में किसी चीज़ को उनकी ज़रूरत नहीं है s3।
Fan-out एक chat से ज़्यादा महँगा है। Anthropic का अपना research system अपनी multi-agent cost को chat से नापता है, किसी single agent से नहीं, इसलिए उस आँकड़े को subagents बनाम एक loop न समझें s14। Single agent से हमारी तुलना ऊपर की scout table है।
Subagent बनाम skill, एक पंक्ति में। Subagent fresh, isolated context के साथ शुरू होता है; skill आपकी main conversation में चलती है, जहाँ session पहले से repo जानता है। इसीलिए folded test writer तेज़ था।
Forks और resume करना। Fork पूरी conversation inherit करता है, fresh शुरू नहीं करता, और रुके हुए subagent को उसके पूरे history के साथ resume किया जा सकता है। हमने दोनों में से कोई test नहीं किया; इन पर निर्भर होने से पहले subagents docs पढ़ें s2।
कई builders। एक साथ लिखने वाले parallel builders हमारे दायरे से बाहर थे। शुरू करने का नियम "पढ़ना fan out होता है, लिखना अकेला रहता है" है s8।
Persona agents। Architect, product manager और दूसरे org-chart agents वही हैं जिन्हें test हटा देता है। Anthropic का article चेताता है कि agent architecture org chart की नक़ल बन जाती है s1।
FAQ
क्या scout हमेशा context बचाता है? नहीं। हमारे तीन छोटे सवालों पर उसने लगभग कुछ नहीं बचाया, और आम searches पर fan-out से ज़्यादा कुछ नहीं मिला जबकि खर्च बढ़ा s5। उसने बड़े पढ़ने पर फ़ायदा दिया, जहाँ main session छोटा रहा।
Reviewer के पास Edit या Write क्यों नहीं है?
ताकि वह जो पाए उसे ठीक न कर सके, और Agent हटाने से वह helpers शुरू नहीं कर पाता s2। tools छोड़ देने पर उसे हर tool मिल जाता, क्योंकि छोड़ा गया tools सब कुछ inherit करता है s2।
मेरे builder के worktree में मेरा uncommitted काम नहीं था। क्या यह bug है? नहीं। Worktree default रूप से आपकी default branch से बनता है, उस जगह से नहीं जहाँ आप हैं s2। जो builder को चाहिए उसे पहले commit या merge करें।
आपके repo पर test writer हार गया। क्या मेरे पर भी हारेगा? शायद नहीं। हमने एक छोटे repo पर हर तरफ़ बारह runs चलाए, और subagent की एकमात्र चूक ऐसा test command थी जिसकी हमारी settings ने इजाज़त नहीं दी थी। Harness को अपने repo पर चलाएं और हर उस run को पढ़ें जो पलट जाए, जैसा article सलाह देता है s1।
क्या मैं reviewer को background में चलने की जगह इंतज़ार करवा सकता हूँ? 2.1.198 से subagents default रूप से background में चलते हैं s24। Docs में Claude से उसकी report का इंतज़ार करने को कहने और एक ऐसी setting का ज़िक्र है जो उसे इंतज़ार करवाती है; अपने version के लिए subagents docs देखें s2।
AIDive