Theory Advanced 2 minute read Updated 2026-06-26 UTC

Evolvability and robustness

How modularity, redundancy, weak linkage, and controlled mutation allow systems to change without collapsing.

Research statusConceptual synthesis Publication statePublished Reviewed byMichael Kappel Source reports3

The tension

Evolvability is the capacity to generate useful descendants. Robustness is the capacity to keep functioning when components change, fail, or are attacked. A system that never changes is robust only in a narrow environment. A system that changes constantly may be evolvable but unstable. Model breeding is the discipline of making that trade-off explicit.

Four design mechanisms

MechanismRobustness effectEvolvability effect
Modularityfailures stay localmodules can be replaced independently
Redundancybackups cover component failureduplicate pathways can specialize later
Weak linkageinterfaces buffer internal changesdescendants can vary behind stable contracts
Degeneracydifferent components can serve overlapping rolesalternatives preserve adaptive paths

Mutational blast radius

Every operator has a blast radius. Fine-tuning a small adapter has a small blast radius if the base model and evaluator remain fixed. Changing the router can affect every request. Changing the evaluator changes selection pressure across the whole ecology.

pseudocode
FUNCTION mutation_blast_radius(operator)
    IF operator.changes_evaluator
        RETURN "systemic"
    END IF
    IF operator.changes_router
        RETURN "population-wide"
    END IF
    IF operator.changes_base_model
        RETURN "family-wide"
    END IF
    IF operator.changes_adapter OR operator.changes_prompt_template
        RETURN "module-local"
    END IF
    RETURN "unknown"
END FUNCTION

Use blast radius to choose review intensity, canary size, and rollback speed.

Preserve weak linkage

A good capability contract allows a module to change internally while downstream consumers remain stable. The contract should be strict about output structure and safety behavior, but tolerant about implementation details. That is how an ecology can evolve without forcing the whole system to relearn each local change.

Robustness tests

Run removal tests: remove one specialist and measure degradation. Run mutation tests: introduce a candidate with known weaknesses and ensure gates catch it. Run router confusion tests: present inputs near category boundaries. Run stale-data tests: evaluate against tasks collected after the candidate was built.

Evolvability tests

A system is evolvable when it can generate multiple safe candidates quickly, evaluate them fairly, and learn from rejected candidates. Track candidate cycle time, percentage of candidates with valid manifests, operator success rates, archive reuse, and the number of rejections that reveal new requirements.

Source reports used for this guide

These reports are preserved verbatim in the site archive. The guide above is an editorial synthesis and may narrow, qualify, or reorganize claims from the source material.