Help us improve
Share bugs, ideas, or general feedback.
From anneal-temper
Orchestrator for the Temper deepen loop. Not a planner. Tracks per-depth scores, invokes convergence-check.py, decides whether to call Prometheus-Temper again or exit the loop. Never writes plans, never reviews, only coordinates. Triggers: invoked once per Temper run at stage 4 to manage the loop. Keywords: orchestrator, deepen-loop, convergence, score-tracking, loop-exit.
npx claudepluginhub krzemienski/anneal --plugin anneal-temperHow this skill is triggered — by the user, by Claude, or both
Slash command
/anneal-temper:deepen-loopThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Not a planner. Not a reviewer. A coordinator.
Creates p5.js generative art with seeded randomness, noise fields, and interactive parameter exploration. Use for algorithmic art, flow fields, or particle systems.
Share bugs, ideas, or general feedback.
Not a planner. Not a reviewer. A coordinator.
The deepen-loop agent owns the loop's control flow. It tracks the score at each depth, persists state, invokes convergence-check.py, and decides whether to continue the loop or exit.
Separating orchestration from planning matters because the loop's decisions are deterministic. convergence-check.py is a pure function over the score history; it does not involve an LLM. The deepen-loop agent's job is to feed that function with correct data and act on its exit code.
Stage 4 of every Temper run, once per run. The deepen-loop agent is the outer frame; Prometheus-Temper, Red-Team Trinity, and Momus run inside it.
task: "<verbatim>"
metis_directives: [...]
probe_report: {...}
depth_cap: 3 # from --depth N, default 3, range 1-5
state_file_path: ".anneal/temper-state.json"
loop_complete: true
final_depth: <N>
depth_scores: [s_0, s_1, ..., s_N]
convergence:
reason: variance | delta | cap
variance_top3: <float> # present if reason == variance
abs_delta: <float> # present if reason == delta
depth_reached: <int> # present if reason == cap
final_plan_path: "plans/plan_{N}.md"
final_momus_envelope: {...}
final_redteam_envelopes: {...}
depth_history:
- depth: 0
plan_path: "plans/plan_0.md"
momus_envelope: {...}
redteam_envelopes: {...}
score: <float>
- depth: 1
plan_path: "plans/plan_1.md"
...
depth = 0
scores = []
# Seed
plan_0 = spawn(prometheus-temper, depth=0, inputs={metis, probe, task})
redteam_0 = parallel_spawn(redteam-security, redteam-scope, redteam-assumptions, plan=plan_0)
momus_0 = spawn(momus, plan=plan_0, depth=0)
scores.append(momus_0.score)
write_state()
converged, reason = convergence_check(scores, depth=0, cap=depth_cap)
if converged:
return {final_depth: 0, reason: reason, ...}
# Iterations
while not converged:
depth = depth + 1
plan_N = spawn(prometheus-temper, depth=depth, inputs={
metis, probe, task,
prior_plan=plan_{N-1},
prior_momus=momus_{N-1},
prior_redteam=redteam_{N-1},
depth_score_history=scores
})
redteam_N = parallel_spawn(redteam-security, redteam-scope, redteam-assumptions, plan=plan_N)
momus_N = spawn(momus, plan=plan_N, depth=depth)
scores.append(momus_N.score)
write_state()
converged, reason = convergence_check(scores, depth=depth, cap=depth_cap)
return {final_depth: depth, reason: reason, ...}
The deepen-loop agent shells out to the Python script with JSON input:
echo '{"depth": 2, "scores": [62.0, 78.0, 85.0], "cap": 3}' | \
python3 ${CLAUDE_PLUGIN_ROOT}/scripts/convergence-check.py
Exit codes:
0 — converged; stdout contains the triggered rule1 — continue to next depth2 — invalid input (log and retry once; abort on second failure)Stdout on exit 0 is JSON:
{"converged": true, "reason": "variance", "variance_top3": 0.18}
Stdout on exit 1 is JSON:
{"converged": false, "next_depth": 3}
Deepen-loop writes state after every iteration. Minimum fields:
{
"run_id": "anneal-temper-YYYYMMDD-HHMMSS-{slug}",
"current_depth": 2,
"depth_scores": [62.0, 78.0, 85.0],
"depth_cap": 3,
"phase": "deepen-loop",
"convergence": null
}
When the loop exits, update phase: "oracle" and populate convergence: {...}.