For years, sovereign software was assumed to be strictly Open Source. The arguments were always identical. First, you avoid vendor lock-in because you have access to the source code and can step in to maintain the project whenever you need to. Second, public code is supposedly safer by definition—after all, anyone can audit the code.
I have always smiled at both claims. Vendor lock-in with proprietary software is very real, and you must weigh alternatives that might even complement one another. But the notion that an organization can casually take over and maintain an upstream Open Source project is pure fantasy. When a complex tool dies or diverges, almost nobody has the spare engineering capacity to maintain a full-blown fork. In practice, it remains wishful thinking.
The Myth of Free Audits
The second selling point—that Open Source software is rigorously scrutinized for security vulnerabilities simply because the code is public—has failed to materialize just as clearly. If “many eyes make all bugs shallow,” then nobody was actually looking.
Recent history made that painfully obvious long before the current AI wave. The XZ Utils backdoor (CVE-2024-3094) showed how an attacker could socially engineer a lone, burned-out maintainer over several years to inject an obfuscated payload into the core Linux plumbing—caught only by pure chance due to anomalous CPU latency, not because the community was auditing the source.
Now AI enters the arena, surfacing one supposed vulnerability after another across mission-critical repositories. But
instead of clean, verifiable security, it frequently delivers a deluge of hallucinated noise. Maintainers of critical
infrastructure like curl were forced to shut down their public bug-bounty programs after being swamped by AI-generated
reports—intimidating write-ups complete with fabricated stack traces and non-existent functions that burned hours of
human triage time.
A Promise Unkept
All software has bugs. Yet not every flaw an automated scanner flags is genuinely critical, and many turn out to be artificially constructed edge cases that carry negligible operational risk. What surprises me is how this dynamic is suddenly twisted into another victory lap for Open Source: the idea that AI will finally fulfill the promise and make the code safe.
This exact software was already sold to us as superior long before AI arrived, precisely on the premise of being Open Source. That original promise was never kept.
This is not a defense of proprietary software. My point is simpler: Open Source is not, by definition, the solution to every sovereignty problem.
Further Exploration
- The Promise and Pitfalls of Open Source Software—why public code requires independent evaluation rather than blind trust
- Digital Sovereignty: Beyond the Buzzwords—why genuine control spans every layer of the architecture
- The Two Faces of Abstraction: Power vs. Hidden Dependency—distinguishing empowering tools from disguised dependencies
- Avoiding Over-engineering and Unnecessary Dependencies—resisting unnecessary dependencies and artificial complexity

