For most of software history, failure announced itself. A program with a defect crashed, threw an error or produced output so obviously wrong that someone noticed by lunchtime. The failures were loud, reproducible and traceable: The same input produced the same wrong answer until somebody fixed the code. An entire discipline of quality assurance grew up around that predictability, and it served us well for decades.
Modern AI doesn’t always fail so visibly. A large language model can provide a confident, fluent, and entirely wrong answer, while an autonomous agent can take an incorrect action, with no visible signal that anything is amiss. Ask the same question using slightly different wording, and the response may change. Leave the system running in real-world conditions, let data drift away from its training distribution, and its performance may degrade silently: No crash, no error log, only answers or decisions that grow quietly worse while appearing just as convincing.
I’ve spent much of my career building enterprise automation in high-stakes domains, from compliance expert systems to financial automation platforms, much of it built on Microsoft technologies. Having watched automation evolve from rule-based interactive voice response systems and early virtual assistants to today’s fully agentic AI workflows, I’ve seen firsthand that in such domains, an incorrect answer or action is never a minor inconvenience.
These new failure modes change what responsible deployment requires: Governance is no longer a compliance chore appended to AI projects. It’s the mechanism by which AI remains trustworthy enough to keep using.
A new class of risk, not a new set of edge cases
It’s tempting to file these behaviors under “known issues” and move on—every technology has quirks. That framing understates the problem. What AI introduces isn’t a longer list of edge cases but a different class of systemic risk, and it differs from earlier software risk in two ways that matter operationally.
First, it spreads faster. A flawed formula in one spreadsheet damages one report. An AI system embedded in a workflow touches every decision that flows through it, and organizations deploy these systems precisely because they scale. The error rate doesn’t need to be high for the harm to be large—it needs only to be multiplied by everything the system touches.
Second, it’s harder to detect. Traditional defects are binary and reproducible—the test fails, the bug is filed. AI failures are probabilistic and fluent. The wrong answer arrives in the same polished prose as the right one, at the same speed, with the same apparent confidence. The traditional signal of trouble—visible breakage—is simply absent. By the time a pattern of quiet errors becomes undeniable, it’s often been compounding for months inside decisions no one thought to reexamine.
This is why governance has moved from the appendix to the architecture. When failure is loud, you can afford to react. When failure is silent, you must design for detection in advance—because nothing else will tell you.
Old principles, new stakes
The good news is that the safeguards aren’t exotic. They’re long-standing principles practiced by engineers who build high-stakes systems, now applied to a technology that makes them urgent for everyone. They include:
•Transparency: It must be possible to see what the system decided and on what basis.
•Reversibility: It must be possible to undo what the system did.
•Confidence calibration: The system shouldn’t sound certain when it’s not, and its expressions of confidence should correspond to its actual reliability.
•Respect for the boundary of human judgment: Some decisions carry consequences that machines should inform, but people should make.
None of these ideas is new. What’s new is that they can no longer be treated as aspirations. In a world of fluent, silent failure, they’re operational requirements.
Another lesson that experience in regulated industries teaches: Governance works best when it brings diverse perspectives to the table. The engineering view alone may optimize for what’s measurable; the business view alone may optimize for what’s profitable this quarter. Add perspectives from legal, compliance and ethics, along with—critically—those of the people who will live with the system’s decisions, and the governance process begins catching problems that any single perspective might miss.
This is also why governance must be built in rather than bolted on. A review board convened after deployment can only document risks that have already been accepted. Governance designed alongside the system can prevent some of those risks from arising in the first place.
Building governance that keeps pace
Four practices convert these principles into daily operation.
1. Keep a human in the loop wherever a wrong answer carries real consequences.Not everywhere—reviewing everything is a slower way of automating nothing. The discipline is triage: Identify the decisions where an error costs money, rights, safety or trust, and place human judgment at exactly those points. Make the review real, not ceremonial. An approver who rubber-stamps 200 items an hour is a checkbox, not a control.
2. Ground AI outputs in your own trusted data.An answer that cites its sources from your verified repositories can be checked against something real; an answer conjured from a model’s general training cannot. Retrieval from governed data doesn’t make a system infallible, but it converts “trust me” into “verify me,” and dramatically narrows the room for confident invention.
3. Make automated decisions transparent and reversible.People affected by a decision should be able to see that it was automated, understand the basis for it, and reach a path to reverse it. Log what the system decided and why. Design the undo before you need it: reversibility retrofitted after an incident is expensive; reversibility designed in is nearly free.
4. Monitor continuously and assume drift.The model that passed evaluation in January is operating in a different world by June: data shifts, usage shifts, model updates by the vendor. Track output quality against reference cases, watch override and correction rates, and set thresholds that trigger review. Static approval of a dynamic system isn’t governance; it’s a photograph of a moving object.
None of this slows AI adoption—that’s the misconception that keeps governance underfunded. In practice it’s the opposite: Organizations with real governance are the ones that can say yes to ambitious deployments because they can see what their systems are doing and correct course when it matters.
Trust, once again, turns out to be the operating currency. Older software earned it by failing loudly and getting fixed. Modern AI must earn it differently—through transparency, human judgment and vigilance designed in fromthe start. Governance is simply the name for making trust routine.
