The technical causes behind AI safety failures are not abstract concerns for the future, they are concrete design decisions happening today, and they demand the same rigorous attention we give to any system architecture. A recent analysis of AI harms and their technical origins makes this painfully clear: when safety breaks, it often breaks because of how the system was built, not because of some unpredictable external force. This shifts the conversation from blaming users or lamenting complexity to something far more actionable. For anyone building or deploying AI tools, this means looking inward at the engineering choices that create vulnerabilities in the first place.
The parallels to distributed systems thinking are direct. In Designing distributed systems for decisions, not just functions, we explored how moving from microservices to agentic AI architectures requires a fundamental rethinking of how decisions are made across a system. The same principle applies to safety: if you treat safety as a separate layer bolted on after the fact, you inherit the same brittleness that plagues poorly designed distributed systems. Safety must be a property of the architecture itself, baked into how components communicate, how data flows, and how decisions are escalated. When a system is designed for functions rather than decisions, it becomes nearly impossible to trace a failure back to its root cause until it is too late.
There is also a statistical lesson here that should not be ignored. In When Data Tells Two Truths, the Paradox Reveals the Insight, we saw how combining data can reverse the story entirely. AI safety failures often follow a similar pattern: a model performs well on aggregate metrics but fails catastrophically on specific edge cases. If your evaluation pipeline only looks at overall accuracy or loss, you will miss the very conditions that cause harm. The technical fix is not just better training data or more fine-tuning, it is designing evaluation systems that surface paradoxes rather than hiding them. This means testing for disaggregated outcomes, building guardrails that trigger on specific failure modes, and accepting that a single number can lie about safety.
The most practical takeaway is this: treat the technical roots of AI safety as you would treat a bug in production code. Trace it, document it, and fix the architecture, not just the symptom. If your team cannot explain exactly which design choice prevents a specific harm, that harm is already waiting to happen. Watch for systems that promise safety through black-box monitoring or post-hoc audits without revealing the structural decisions underneath, those are the systems most likely to fail in ways you cannot anticipate.