The granularity dilemma — how fine to split

Parent: recursive-harness

Split a complex task finer and the splits themselves are more likely wrong; split coarser and the children are more likely to fail. Both risks are real — so there is an equilibrium, and better, there are techniques that move it.

The U-curve: granularity is the harness's capacity knob

Let the task have size S, split into n leaves of size $s = S/n$ . Two risk terms:

split risk ≈ $(n-1)\cdot\alpha_{\mathrm{split}}$ — each split is a fallible move with its own α (safe-recursion-theorem); more splits, linearly more chances to poison a subtree;
leaf risk ≈ $n \cdot \varepsilon(S/n)$ — and ε(s) is convex and steep in leaf size, because of the competence landscape (coupling-to-the-learner): big leaves fall off the training manifold. So this term falls as you split finer.

Total $R(n) = (n-1)\alpha_{\mathrm{split}} + n\,\varepsilon(S/n)$ is U-shaped — the exact bias–variance shape. Equilibrium = the first-order condition: split until the marginal α of one more cut exceeds the marginal ε-reduction it buys.

Weigh it in P×C, not in probability

The two errors are not the same kind: a split error is systemic and late — the subtree perfectly solves the wrong problem, every leaf gate green, and it surfaces only at the reassembly gate after the whole subtree's budget is burned. A leaf error is local and early — caught by the leaf's own gate at the cost of one retry. So the equilibrium condition must be cost-weighted: compare $\alpha_{\mathrm{split}} \times (\text{subtree cost})$ against $\Delta\varepsilon \times (\text{leaf retry cost})$ — P×C is exactly the right currency, and the weighting pushes the equilibrium somewhat coarser than raw probabilities suggest.

Three techniques that move the curve (better than picking a point)

Choose granularity locally, not globally. The competence landscape is uneven: split fine on unfamiliar terrain, coarse on boilerplate. The stopping rule is already per-branch (leaf spec learnable from its injection — coupling-to-the-learner), so the equilibrium is a contour on the landscape, not a single number.
Probe-then-split (lazy decomposition). Don't commit the full tree upfront. Give the coarse leaf a small probe budget (one attempt + gate); if it fails, split — and let the failure's content (which checks failed) choose WHERE to cut. This is conflict-driven decomposition: the conflict locates the seam, no-goods accumulate in the coordinator, and the static gamble becomes a sequential decision that measures ε(s) instead of guessing it.
Cut along the seams (near-decomposability). $\alpha_{\mathrm{split}}$ is not a constant — it depends on WHERE you cut. Cutting along weak couplings (simon-ando) yields children that barely interact, so the split certificate (⋀Sᵢ + reassembly ⟹ S, root-protocol) is SHORT. Certificate length is a proxy for cut quality: a short entailment argument means a real seam; a tortured one means you're cutting through load-bearing structure. And where fineness is genuinely needed, buy α down: spend more verification budget on the split gate.

The dilemma has an equilibrium (the U-curve in P×C currency), but the craft is in moving the curve — split on seams, probe before committing, and let the terrain set the grain.