We Could Be Free

How AI can break 50 years of software oligopoly and make software sovereign again.

Part 3 of 3 in a series about reclaiming independence from American (Big) Tech.

You are reading the third installment in my series on the American tech exit; you can find part 1 here and part 2 here.

Here, I’ll argue that software ownership has followed a fifty-year trajectory away from user control, but AI is the first major technological shift in decades that has the possibility to reverse that direction. As we’ve become more dependent on a functioning, global software supply chain, the ability to generate usable code at low cost opens the door for shifting both collective, open-source supply chains as well as distilling proprietary tools for simple needs into a vastly pluralistic software landscape, where organizations (again) build more custom, adapted software—but better, and, soon, at near-zero-marginal cost.

The title of this article (“We Could Be Free”) is also the title of a presentation I’ve given at a number of places during 2026, as well as used in my job context, building an EU-sovereign cloud. Though, note that I’ve not strictly replicated the presentation here; instead I’ve opted for a different take on the same subject matter, like a remix.

Both buyers and sellers don’t actually want to move, yet there is much talk of the need to do something.

— Bert Hubert: The European Cloud Situation at the end of 2025

This quote perfectly encapsulates the European zeitgeist and manners, at least up until recently. The fear of changing—which I wrote about recently—has been deeply pervasive in the tech contexts I’ve worked in my career. Now, I even hear horror tales from friends who work in places where leadership is putting their heads in the sand, hoping for the current, violent stir around digital sovereignty to subside, as well as some (but fewer) who are part of navigating their organizations to a new state.

What is it that brings out so many feelings, when we talk about sovereignty?

Sovereignty is actually less complicated than it’s made out to be. I like to illustrate what sovereignty (or in the context of individuals: autonomy) really means by pointing to the “Free Britney” movement some number of years ago.

As you might recall, Britney Spears, after suffering a mental breakdown, was put under conservatorship for more than a decade. During those long years, she was free—as in not incarcerated—but had limitations set upon her de facto possibility space, including handling her own finances and personal affairs. When Vladimir Putin falsely claims that Ukraine is not sovereign, he is asserting that Ukraine has no right to make its own decisions or govern itself independently.

Both examples are similar in spirit: An outside actor is exercising powers to limit your options.

Was Britney “sovereign”? Well, you can ask yourself a guiding question:

Are you free, if you cannot leave?

Then the answer would be “no”.

In software, this can happen when dependencies accumulate, contracts start to lock you in, or data becomes difficult to move. The effect is that leaving becomes expensive, risky, or simply impossible. This isn’t new, but it has become much more precarious in the world we live in today.

Sovereignty implies autonomy, self-determination, and respect for one’s being as independent, that is, by others. When the economic system has been so deeply globalized as it has in the last 30–40 years, the explicit mention of “sovereignty” chafes badly on unspoken expectations around global, mutual respect and kinship, as well as ideas of mutual gain that have been taken for granted today. The use of the word itself casts a shadow of not just independence, but also of the bad old days, where nations could have a more purely nationalistic agenda under the guise of sovereignty.

Still, sovereignty is a basic, root concept that is very hard to be without as a nation state — it would abolish the very right to be a nation in the first place. Yet, quite problematically, the economic system has, in ways, grown beyond sovereignty as a “ simple, national-only” concern: It’s not every country against everyone else — we collaborate and trade, at least in the recent history. A key component of why sovereignty is back on the table, and why explicitly there is a major struggle in regional bloc politics, is that the ideas of mutual gain have been cast into doubt, most clearly by President Trump.

When Trump calls into question the global economic system, he also wants others (EU, Venezuela, China, Iran, pretty much everyone…) to be subject to the US position. That play is imperial in nature, not globalist, nor is it mutual-gain-oriented pragmatic capitalism. Sovereignty is what lets anyone else assert and stand their position. Imperialism is not a given outcome of that—that is a choice the US made.

However, here my focus is on software, not outright politics. So, what does this mean for the software industry?

We can take the above characterization and apply it to the dynamics of our industry. We can then apply it to questions like:

• What created the “imperial” (or hegemonic, even oligopolist) software market?
• Why is it so hard for organizations to look for, and select, alternatives to common software like Microsoft Office?
• Why is the immense political energy around digital sovereignty still largely seen as political theater, rather than an actual challenge in many organizations?
• What can change the current situation in favor of organizations’ needs?

Let’s go back in time and find out.

This is the short version if you want the gist:

• We can see that something strange happened to software over the last fifty years: The more powerful software became, the less we owned it.
• With the first computers, software wasn’t even a product. It was written specifically for the hardware it ran on. If you needed software, experts wrote it for your machine. The software became yours.
• Later, software became something you licensed or bought in a box. Whoever controlled distribution controlled the market.
• Then the internet arrived. Distribution became cheap and global. Software could reach billions of people and the software market expanded in kind.
• By the time we hit the second millennium, something important had disappeared: Ownership. Instead of buying software, we began renting it. In our era, the companies renting software to you are the winners.

The customer: from one-of-a-kind stakeholder to pirate to owner to renter

To understand the current-day scenario, it’s useful to have an overall understanding of the software economy and how it evolved. The story will be around how value capture and the notion of software ownership has changed during the history of computing.

Let me walk you through some of the most significant events.

Early days and the snowflake customer

With the very first, modern computers (~1940s) there existed essentially no software, at least as a commercial product. Consultants from the hardware manufacturers were brought in to write software for you. Thus, you owned the software.

On the flip side, there was no market for software since only the hardware was being sold and few used computers. Also, there existed very few common languages or conventions—even if you had code to share, there was very little guarantee it would work anywhere else.

Sharing the learnings across a nascent industry

Two decades later, enthusiasts would circulate specialist magazines that leveraged a growing degree of standardization and common technical architectures. At this point there was also an audience of programmers available to share code with. In the magazines, you could find entire (small) programs for leisure as well as professional contexts. Far before open-source, this was how code was circulated. The code was always effectively understood as being “public domain”, given the nature of its distribution.

The long legal arm and professionalization of software

In 1975, a young Bill Gates wrote his angry “open letter to hobbyists” as a response to wide-spread piracy of one of his first commercial programs, BASIC. By this time, the audience had far expanded and the practices of the last decade, sharing code, and having little legal protection, was now ripe for evolution. This was the first step where we start to see the evolution to the IP-rights-centric business that software is today.

Boxed software started to become available in computer shops in the late 1970s. Putting software in a box made it attract much more attention: buyers could physically see the software next to hardware, and gain the understanding that the major movements were now to happen on the software layer and not only on the hardware level. However, just like today, physically producing and distributing troves of these boxes is expensive, meaning only the larger software houses could afford doing this. This is the period where some of the very largest software producers cut their teeth. Look no further than Microsoft and Oracle, but you’ll maybe not remember Lotus or Applied Data Research if you are younger than 50.

Moral of the story: If you had lots of money and could put product on shelves, then you could make more money. It’s the familiar self-perpetuating cycle of capitalism.

Indie-style producer-led distribution

During the late 1970s up until the mid/late 1990s various schemes for producer-led distribution proliferated, of which the most well-known variety was shareware, though shareware itself also had many different configurations and varieties. The shareware movement was primarily a way of ensuring effective, cheap (to the buyer) and high-margin (to the seller) distribution of demo (or limited) versions of proprietary software. A typical example is that you’d place a few dollars in an envelope, post it to a company sitting way out in the sticks, and they’d post you a 3,5" floppy with a demo version of an application or game. To unlock the full version, you’d either send more money or telephone them and get an unlock code. Shareware was the first major example of how a full distribution chain could be crafted and utilized, even by minor producers.

My highest recommendation for anyone wanting to read up on this period would go to Shareware Heroes, and if you are a gamer you might also be interested in Masters of Doom and Britsoft: An Oral History, both of which touch the particulars of working during that era. For Swedish readers, Svensk Videospelsutveckling by Martin Lindell is equally interesting—note also how much smaller the Shareware scene was outside the US and UK.

Unfortunately, much of the Shareware play became co-opted by publishers creating shovelware (the equivalent of AI slop in those days by junior coders building buggy, poor software in just days) or, especially with CD-ROM devices becoming popularized and cheap in the 90s, rebundling others’ software on massive disks, effectively selling high-margin bundles of hundreds of apps or games, exhausting the quality-driven original approach. Shareware producers started to lose money and the uphill battle got really steep.

In hindsight we can see how there was now a real market: becoming popular for both producers and consumers, cheap(er) to buy for consumers, as well as seeing a vast increase of people knowledgeable in making software. People understood that software costs money, but with mega-disks of content floating around; I recall myself buying these when I was 8–10 years old. It’s also the first taste of the App Store “race-to-the-bottom” pricing. You can easily move on the next game, even if the first episode of Doom was mind-blowing. With less-than-legendary games, the net outcome is that people no longer paid just for novelty when you suddenly had hundreds of games to choose from.

Software becomes truly global

Meanwhile, the internet exploded onto the scene. Folks got connected and the internet went from a weird, secluded scientist-led thing to a folksy agglomeration of private home pages, first- and second-generation commercial platforms, and a massive closing of distances, both between people and cultural expressions, as well as software. The internet almost immediately took the place as the distribution platform, though there was a bit of an on-ramp given the slow connection speeds versus the reality of storage needs—downloading a full CD-ROM, if it would even fit on your hard drive, would take days on dial-up modems.

For producers, this evolution was partly good, as it followed on the same positive principles that Shareware came with: producer-led, relatively high-margin, simple and effective distribution. However, with the extreme widening of the market and the overall globalization, now attention was at the forefront… and buying attention is expensive. This is when we see very old media patterns re-engage with the newfangled internet: owning channels, advertising (and increasingly, search results), and doing lobbying are all, in media terms, ancient ways to capture customers. Software was now under immense competitive pressure. While the cost of making software did not necessarily go down, the costs to sell and market went up. In this era, once again, it is often true that money wins; being in the first five results in a Google search when people look for their next productivity tool decided a lot of the market.

The eternal customer

Today, we live in the tail end of an era defined largely by SaaS and cloud computing. Now, applications (and to an ever-increasing extent games and other digital products) are things you rent, not buy. This is why, for example, Sony or Apple can pull your licenses for films you legitimately “bought”. In fact, you agreed to purchase a license to see the film, not to perpetually own it. Business software went down this route decisively in the last two decades—it’s almost unheard of to find companies selling perpetual (or physical!) copies any longer.

Concurrently, the open-source movement goes from ideological to highly practical and commonplace. Open-source software starts to account for the vast majority (70–96%, based on language and study) of code, including in enterprise contexts. I might be cynical when I reflect how the exploding factor for open-source becoming widely accepted in enterprise was probably the (misunderstood) impression that open-source code is “free”. Years ago, I wrote about how to deal with some of that but I’m on the fence whether there is generally a better understanding of how to handle open-source, in the wild, today.

Over time, I’ve come to be fairly critical of open-source, less for ideological than for practical reasons. We need to remember that it’s a key software supply chain component—even doing a PR to improve a package is suddenly dependent on external actors and their processes, and these people may very well not be salaried or have the incentive to do a timely merge of your hard work. No doubt, open-source helped accelerate software development shipping compared to the “old days”, but we also became vastly more globally dependent, especially on a mesh of actors whose organization shape, size, and incentives no longer neatly align.

While this era ushers in convenience and forms a fairly logical evolution, the main drawback is that your business relation is now completely transformed: from owner to renter. In the last decades, the winners were software companies who can leverage a flywheel like so:

• Grab attention, as per the attention economy accelerating with the spread of the internet and faster media consumption patterns;
• Provide zero-effort access, exemplified best by the one-click sign-up pattern using common identity providers like Apple, Google, Microsoft, GitHub, et al;
• Use a “free plan”-centric product-led growth approach, where customers have come to expect not just zero-effort but also, effectively, zero cost, up until (typically) they want more advanced features;
• Go for growth at any cost, since giving away software as per above (even if it’s cloud-based) still costs money, someone has to financially back the company during the non-profit-making period—this usually happens to be venture capital looking for double digit multiplers (at least) down the line;
• Do yearly (or more frequent) price hikes, where customers get caught because of things like switching costs, organizational drag, or outright vendor lock-in—and this might still not be enough to make the software business viable.

The customer is now deeply connected to a rental economy, all based on an extreme logic of venture-capital-backed market capture. Granted, there’s plenty of process and technical improvements in the SaaS era, including not having to deal with physical media. However, there’s nothing teleological happening here that requires the above set of actions to be performed.

How organizations changed since the 2010s

With the gargantuan money that was to be made in the software industry, everyone (including kitchen appliance and car manufacturers, the gardening sector, and toy industry) all wanted to call themselves software-driven. Some of that is today less prominent and less expressed, but for 10–15 years the running agenda was to empower CTOs to essentially rethink industries, hyper-transforming them from the mechanical world to the digital mindset. Some of it fairly successfully (e.g. connected cars with automated assistance for crashes and accidents) and some of it less so, such as internet-connected toys with video feeds for small children. There’s many bad examples.

The eager organizations also seem to have missed the fundamental economic differences: competing from European soil, with European-style orgs and markets and financial conditions, trading in real-life tangibles, going against immaterial American, venture-backed software that’s in many cases largely supported by advertising revenue or other conventional, non-software revenue streams. I’m no economist or CFO, but I’m surprised this was called out less often than it should have.

Software is now — for better or worse — arguably so naturalized a component through so many verticals that it’s less attention-grabbing today than it was just a few years ago. In this shift, a lot of industries did become more software-oriented, but as I’ve also stated multiple times (here, here, and here), being software-first is something very different and alien for these organizations. I’ve yet to see an actual, real transformation of that kind in any of the enterprises I’ve worked for or have insights into.

If this historical trend ended there, the story would simply be one of increasing dependence. Now, AI changes the economics enough that the trend may finally reverse.

A new sovereign frontier?

Near the introduction of this article, I asked “are you free, if you cannot leave?” as a marker for whether or not you are sovereign. While certainly a simplification, it’s useful, since it’s easy to see all the cases where this is not true.

For me, AI is the tool that can help expedite sovereignty because it materially changes the playing field. For years, we were caught in the deeply problematic position of being “endless customers” for ever-worsening services. AI changes the picture because it compresses the cost of producing code to much, much less than before and brings back software production to the actual users, rather than requiring a vendor-buyer relationship.

As a side note, I don’t think the current situation of token pricing and non-functioning market price-setting is going to be permanent, nor is it fully true: there’s plenty of good work to be done with strictly cheap models, including running capable coding models locally at essentially zero cost beyond the increased power usage.

While entire books could be written on the merits of generated code, especially in common high-level languages, the answer is clearly yes. Moving with the going indications of 1) price compression is happening, and 2) the quality of output is adequate, then that’s already enough to put the current software situation off kilter.

My personal angle—as part of my long journey to remove as many dependencies, especially American tech ones—has been to rebuild a base layer of functionality, if nothing else to support me and to evidence the claim that AI can make you more sovereign and thus more independent.

The first example of this is MikroSuite, a family of small tools and libraries that cover both technical needs but also broader productivity use cases. I wrote about it here, too.

Pre-empting AI usage by many years, I began building this suite in a zero-dependency manner strictly because I’ve for years advocated simple, small, useful software. Not finding what I needed in the Node.js community, I built a whole bunch of these tools to first and foremost satisfy my own needs. Over time, as the approach and technical strategy solidified and code examples started accumulating, it was easy to add AI-assisted code generation and express new ideas, using the familiar path from the older work. This is how some of the more recent productivity additions made it, and how the Mikro family grew into the formal MikroSuite packaging.

MikroSuite demonstrates that many desktop productivity tools can now be recreated and iterated upon by individuals rather than software companies. A driving angle for MikroSuite has been that you can never be more sovereign than running your software locally (unless online sharing and collaboration are natural components). This is yet another factor that is getting squeezed from the market—even many open-source apps “offer” a required online mode, something I wanted to completely remove.

MikroSuite productivity tools are not intended to compete on feature-by-feature with any specific commercial offering. Instead, I’ve tried to rethink what these tools should be, and how we can make them as minimal and compact as possible—in code and visual design. They borrow some manners and tastes and invent others, but always with a clear notion of what “Mikro” means.

For my second example, I built MolnOS (“Cloud OS” in Swedish and also a nice name overall!) because I’ve had the idea for years to find an answer to what a microscale, portable cloud would be.

Could there be a cloud that was resembling a commercial cloud, that was useful and actually good, and that could be run on a potato? Yes, but instead of a potato I needed whatever minimal computer can run Linux, which could indeed be as small as a Raspberry Pi Zero 2.

MolnOS demonstrates that cloud infrastructure can be radically compressed while remaining useful. Leaving old truths behind makes this not just derivative but innovative as well.

More about MolnOS here, and you can always see more on my website for other work.

Both of these projects are hardly non-trivial, nor would I call either of these quite substantial works “vibe-coded”, implying they lack quality control or meaningful architectural concerns. Both projects prove that it’s possible to replace software that was previously considered impossible to replace, at least in spirit. While replacing AWS for most people would take more than MolnOS (to be fair, for many things MolnOS might be better), replacing your word processor or chat application is not critically hard.

And more importantly than trite discussions on AI-generated code being good or bad, AI-assisted coding opened up doors to venues that I either would never have tried, or that I was locked out of, for competence reasons. Going from idea to discussion to plan, and then execution, is truly like having a really good colleague with you. But, just like people, AI does the wrong thing every once in a while. This is not reason enough to discard AI code generation.

AI changes the historical direction as it’s now becoming entirely possible to assert your sovereignty by building your own software “base layer”. This loose concept wraps a lot of the types of software that most individuals and/or organizations deem essential for day-to-day operations.

What, then, about the SaaSpocalypse which loomed over early 2026? Wasn’t that supposed to predict the software market collapse, and that didn’t happen?

Yes, that’s tangentially related, but realistically there are still a ton of factors (compliance, security, quality, operations…) involved in software that are more people and organization-bound, than they are code/programmer/agent-bound; see a counter-point to SaaSpocalypse here. Where the narrative has been around the cost of software approaching zero (in theory), the even more enticing angle is that you could break free of negative dependencies, thus why I keep pointing to replacing the software base layer, rather than willy-nilly vibe-coding random business processes.

For a concrete, large-scale example, look no further than the French government banning Windows in favor of Linux (open-source over proprietary software) and also building their own productivity suite, Visio, rather than running American SaaS such as Zoom. Vibing your way to the next Linux is realistically a road too far, but replacing “impossible to switch” software was, well, evidently not impossible.

The dirty but correct thought to plant in your mind is “what if it’s not irreplaceable”. Nothing is.

For decades we adapted ourselves to software because building alternatives was prohibitively expensive. If AI changes that equation — and I think it already has — then digital sovereignty stops being an abstract political slogan and becomes a practical engineering discipline. Suddenly it’s no longer whether we can replace more of our dependencies: it’s which ones we choose to replace first.

Outro: From threat to opportunity

Question: How could the nonexistence of what has not happened be more real than what is now observably over and done with?

Threat is from the future. It is what might come next. Its eventual location and ultimate extent are undefined. Its nature is open-ended. It is not just that it is not: it is not in a way that is never over. We can never be done with it. Even if a clear and present danger materializes in the present, it is still not over. […] Observation: The future of threat is forever.

Fear is the anticipatory reality in the present of a threatening future. It is the felt reality of the nonexistent, loomingly present as the affective fact of the matter. […] Proposition: If we feel a threat, there was a threat. Threat is affectively self-causing.

— Brian Massumi: The Future Birth of the Affective Fact. The Political Ontology of Threat

Nothing is as dangerous as possibility. Possibility and threat are tightly interwoven into any paradigmatic change, such as the one we are living through at the moment. I highly recommend reading Massumi’s excellent essay in full.

What I especially take from the above is that we are quite poor at projecting possible assessed threats into credible actions. Instead, we end up with a “can’t everyone be friends”-style mentality where risk assessment and opportunity scouting is seen as paranoid at best, or at worst, crippling fear of what has yet (if ever) to happen. EU and the European mindset in a nutshell?

No more. We need to respond to the threats with urgency and rigor, looking at practical plays to retain our sovereignty.

The common refrain of “yeah there is a SaaS for that” and — yet again — point to two guys in San Francisco has to stop. The world looks very different when it’s simply not possible to pick that offer any longer, because who sells it is more important than ever. Even Polestar’s CEO went as far as basically saying globalization for automakers is officially over, after having been blocked by the US to sell cars in the that region from 2027 onward. “Offensive defense” is the approach we need — we didn’t ask for these conditions, but it can certainly be navigated. The threats are there, and we need to stop hiding.

It’s not just “what” and “how”, but also “who” you are. My (Swedish) father-in-law is of the generation where he, literally, will not walk into a (privately-owned) ICA food market, being a true believer in the cooperative, federated Kooperativa Förbundet (Cooperative Union), which today exists chiefly through the Coop chain of stores. He’d probably rather be eating rocks than going inside. That opposition might seem quaint to many, but for older generations it was a deep political divide, seen through how you shop and thus who support: the workers or the bourgeoisie. “Where” you went was at least equally important as the functional properties of the goods or their prices of the store itself.

Purchasing software is now becoming a political act in the same way shopping once reflected political identity. That’s part of the zeitgeist and political landscape, sure. But played right, this can be strategically played given the reductions in the cost of software production, which change the political meaning—or dependency and trade angle implied—in software ownership completely, not just on the national/regional level.

When was Slack, Office, or Zoom ever custom-adapted? What if you could have similar functionalities, but uniquely adapted for your needs? Or simply, have a functioning regional market (see European Alternatives and the EuroStack directory)? There’s already a non-US, sovereign alternative out there, and if not, making it will be ever faster and cheaper.

The software industry has spent fifty years optimizing for centralized production because writing software was expensive. But if writing software becomes inexpensive, the optimal industrial structure changes as well, as it has done in the past. What if building is cheaper than being dependent — dependencies that once felt permanent can suddenly be replaced. Even “sovereign software” might be practically extended to mean personal/organizational custom software. That should be enough to make your mind race about the possibilities.

It’s quite likely that the outcome of this paradigm shift will be more pluralistic, adapted, and sovereign software.

The end of globalization is thus not necessarily a bad thing. In fact, it just might be your meal ticket if you’re entrepreneurial.