Recursion + convergence = the real lever
#thread/agent-loop
loop / goal / self-evolution are all just recursion in different clothes. The value isn't in any of them — it's in recursion that converges.
Companion: recursion-is-a-phase-transition — this note is the quantitative side (compounding/contraction); that one is the qualitative side (general recursion as the Turing/Gödel threshold).
Picture — a contraction converges
Iterating a map T with slope k<1 staircases into the fixed point x* (each step closes the gap by a factor k); slope ≥1 would spiral out.
Why recursion = huge value
Recursion compounds: each layer, if it's a verified stable building block, is the base of the next (stages-and-gates recurses; Simon's stable sub-assemblies stack). Linear effort → linear value; a converging recursion → compounding value. A simple verified operator reaches arbitrary depth by recursion (LCF kernel → big proofs; agent → recursive decomposition).
The catch: it only compounds value if it converges
- converging recursion → compounds capability;
- non-converging recursion → compounds garbage = Hermes self-congratulation drift; the ungated-decomposition pⁿ collapse (necessity).
So convergence is the necessary condition for recursion to pay.
Formal heart: convergence = contraction (Banach; order twin kleene-fixed-point; fallible-executor version inexact-contraction — per-step error ε still converges, to a ball of radius ε/(1−k))
A recursive operator T converges to a unique fixed point x* iff T is a contraction:
The contraction factor k = how much each step provably moves toward goal G. k<1 → geometric convergence; k≥1 → drift.
What sets k? — your verification / gate
- grounded gate (mechanical / external ground truth) → each step really moves toward G → k<1 → converges → compounds capability.
- self-judgment (semantic self-assessment, self-congratulation) → step may not move toward G → k≥1 → drifts → compounds garbage.
→ Verification bandwidth = the contraction factor k = decides whether the recursion converges and how fast. This is verification-is-the-new-latency lifted to the recursion level; and Ashby: controller capacity upper-bounds how much variety you can destroy per step, i.e. upper-bounds k.
Everything we discussed, collapsed
- loop / goal = the gate that makes a loop converge to "done";
/goal's semantic judge is a weak contraction (k may not be <1 → convergence not guaranteed) — see loop-termination-is-a-gate. - self-evolution (Hermes/GEPA) = recursion on the agent's own skills/prompts; objective metric → contraction → real; no metric → k≥1 → drift.
- eight controls (control-methods) = convergence accelerators — each control pushes k down.
- stages-and-gates recursion = a real gate per layer keeps the whole recursion a contraction → no pⁿ collapse.
One line
Value comes from recursion's compounding; compounding is positive only when the recursion converges; convergence = contraction; the contraction factor = your verification quality. The high-value system isn't "self-improving" — it's "provably converging," and your verification bandwidth is the hard ceiling on how much value the recursion can compound.
Lever: don't chase "more self-improving"; chase "each recursion layer has a real gate, making the whole a contraction toward G."