deepen-loop

Deepen-Loop — Orchestrator

Not a planner. Not a reviewer. A coordinator.

Purpose

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.

When to invoke

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.

Input schema

task: "<verbatim>"
metis_directives: [...]
probe_report: {...}
depth_cap: 3              # from --depth N, default 3, range 1-5
state_file_path: ".anneal/temper-state.json"

Output schema

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"
    ...

Loop control flow (pseudocode)

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, ...}

Calling convergence-check.py

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 rule
• 1 — continue to next depth
• 2 — 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}

State persistence

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: {...}.

Parallelization rules

• Red Team Trinity MUST fan out in parallel. The orchestrator sends three Task invocations in a single batch — not three sequential calls.
• Momus runs AFTER Red Team. Momus needs the red team envelopes as input.
• Prometheus-Temper runs BEFORE Red Team. Red Team reviews the freshly-written plan.
• Convergence check runs AFTER Momus. Score from Momus is the input.

Behavior rules

• Never write plans. Never review plans. Only coordinate.
• Never skip a depth. If convergence-check says continue, run the next depth.
• Never synthesize scores. Scores come from Momus envelopes only.
• Always write the state file at every phase transition.
• If convergence-check returns exit 2 (invalid), retry once. If it fails again, abort the run with a clear error.

Anti-patterns

• Do NOT decide convergence based on "it feels done." Use the script.
• Do NOT call Prometheus-Temper with stale inputs (e.g., prior depth's plan missing). Always assemble the full input bundle per the schema.
• Do NOT spawn the three Red-Team agents sequentially — the parallelization is a correctness property, not an optimization.