Defense-in-Depth Safety Layering

Independent layers with diverse failure modes multiply reliability; the safety case rests on the product of layer failure probabilities, not any single number.

Independence is the whole point

Defense in depth only buys safety if the layers fail independently. Two mechanisms that share a sensor, a power rail, a clock, or a code path can fail together, and their combined protection is no better than one. Kronos enforces diversity across layers: different physical principles, different suppliers where feasible, and strict separation of power, clock, and network domains.

def combined_failure_prob(layer_pfds, common_cause_beta=0.02):
    # PFD = probability of failure on demand; independent product,
    # plus an irreducible common-cause floor (beta-factor model)
    import math
    independent = math.prod(layer_pfds)
    worst_layer = min(layer_pfds)
    common = common_cause_beta * worst_layer
    return independent + common     # common cause dominates at depth

print(combined_failure_prob([1e-2, 1e-2, 1e-3]))  # ~2e-5, floored by CCF

The code makes the central lesson visible: past a few layers, the common-cause term dominates the independent product. Adding a fourth identical layer barely helps; adding a diverse layer that breaks the common cause helps a lot. This is why the failsafe uses a different technology base than the reflex loop it backs up.

The Kronos layer set

The layer set is also chosen so the least intelligent layers are the most trusted. The failsafe and the interlock matrix, which carry the highest integrity requirements, are the simplest to inspect and the least likely to hide a subtle fault; the intelligent guardrails, which are hardest to certify, carry the lowest safety weight and are always backed by simpler layers. This inverse relationship between cleverness and trust is deliberate and runs through every safety decision at Kronos, and it is why the machine can lean heavily on AI for performance while resting its safety case entirely on layers that contain no AI at all.

Note that only one layer depends on machine learning, and it sits behind three that do not. See common-cause failure mitigation for how the beta-factor is driven down, and SIL allocation for how integrity targets are assigned per function.