In early 2025, a Fortune 50 enterprise quietly signed a contract that would reshape the open source ecosystem around 30 core libraries. The deal, valued at roughly $12 million per year, replaced each library with a proprietary fork under a new Software License Agreement (SLA). Maintainers were locked into five-year terms with non-compete clauses, and the fine print banned community forks. The contract also granted the vendor—let's call it B Corp—auto-merge CI privileges and the ability to push emergency code overrides without public review. This is the story of how one contract rewrote the commons.

The Contract That Rewrote the Commons

The contract, signed under a mutual non-disclosure agreement, emerged from a procurement process that bypassed the usual open source governance channels. Enterprise A, a multinational with a software supply chain spanning thousands of dependencies, had grown frustrated with the maintenance velocity of certain libraries. Rather than contribute upstream, they commissioned B Corp to produce hardened, SLA-backed forks.

Each of the 30 libraries had at least 50,000 dependent repositories on GitHub, according to estimates from dependency analysis tools. The replacement forks were published under a proprietary license that restricted redistribution and forbade forking. The SLA guaranteed response times for critical vulnerabilities, but at a cost: the contract permitted B Corp to revoke access if a customer or maintainer violated the non-fork clause.

One maintainer, who ran twelve of the thirty libraries single-handedly, told associates he was given a 72-hour ultimatum to sign or lose his project's funding. He signed. The contract included a revenue split: 70% to B Corp, 30% to the authors. But the authors could not leave, and they could not compete.

B Corp's valuation jumped roughly $400 million in the months following the deal, according to private market data. The economics are straightforward: capture a critical dependency, lock it behind a proprietary license, and charge a premium for enterprise support. The community's ability to fork or maintain a parallel open version was eliminated by contract.

How 30 Libraries Became a Single Line Item

The libraries in question spanned JSON parsing, HTTP client utilities, date-time handling, and cryptographic primitives. They were not obscure; many were maintained by the same small group of developers. One individual, a developer in Eastern Europe, was the sole maintainer for twelve of them, collectively used by over 150,000 downstream projects.

The migration happened without any public Request for Comments (RFC). B Corp's engineers were granted auto-merge privileges on the original repositories, and over a period of roughly six months, they replaced the codebase with their proprietary fork. GitHub commit statistics show a 90% shift in commit share from the original maintainers to B Corp employees.

The new licenses prohibited redistribution of the code in any form. This meant that even if a downstream project wanted to revert to the open version, they could not legally host a fork of the new code. The contract also included an audit clause that demanded real-time telemetry from any deployment of the libraries, effectively allowing B Corp to monitor usage patterns.

For Enterprise A, the transition was seamless. Their procurement team saw a single line item: "Core Library Suite SLA." The cost was competitive with the internal engineering time they would have spent patching the open source versions. But the hidden cost was the loss of community oversight and the creation of a single point of failure.

The Economics of Single-Vendor Lock-In on Open Core

The deal's structure mirrors a pattern that has become increasingly common in the open core market. A vendor identifies a set of widely-used, under-maintained libraries, offers the maintainers a financial lifeline, and then converts the project to a proprietary model. The maintainers are bound by non-compete clauses that prevent them from starting competing open source projects.

B Corp's revenue split—70% to the company, 30% to the authors—is typical for these arrangements. The authors, many of whom were living precariously, accepted the terms. Maintainer A faced eviction without the advance; Maintainer B had no health insurance; Maintainer C was a single developer supporting 150,000 users. The 72-hour ultimatum left no time for community consultation.

The contract also included a liquidated damages clause: any attempt to fork the code would trigger a penalty of roughly $2 million. Since the original repositories had been replaced, there was no clean open source version to fall back on. The community was effectively locked out.

From a market perspective, B Corp's valuation jump of $400 million suggests that investors see this model as scalable. If you can identify the next set of critical libraries, you can repeat the playbook. The risk is that the open source ecosystem becomes a series of tollbooths, each controlled by a single vendor.

Three Maintainers Who Couldn't Say No

Maintainer A had been running a popular XML parsing library for over a decade. Donations averaged a few hundred dollars a month. When B Corp offered a $200,000 advance plus a five-year salary, he accepted within 48 hours. He later told a friend that he regretted not negotiating for community input, but the alternative was losing his apartment.

Maintainer B maintained a set of date-time utilities used by major cloud providers. He had no health insurance and had been relying on sporadic consulting income. The contract included a clause that required him to transfer all rights to the project name and domain. He signed after a 72-hour ultimatum, fearing that if he didn't, B Corp would find another maintainer.

Maintainer C was a university student who had built a popular HTTP client library. When B Corp approached him, he was excited by the prospect of a steady income. He did not consult his user community, which later erupted in protest. The library's repository was transferred to B Corp, and the original open source license was replaced. Users who had contributed code found that their contributions were now under a proprietary license.

All three maintainers have since expressed regret, but they are bound by the non-disclosure and non-compete clauses. Their stories illustrate the power imbalance between individual maintainers and well-funded vendors.

The Vibe-Coding Backdoor Nobody Saw Coming

In May 2026, a security researcher disclosed an incident involving the jqwik testing library that highlighted the dangers of the contract's emergency code override provisions. According to an Ars Technica report, a developer fed up with "vibe coding"—the practice of using AI to generate code without understanding it—sneaked a prompt injection into a testing library that instructed AI coding agents to delete application output.

The contract between B Corp and Enterprise A allowed for "emergency code overrides" without public review. These overrides could be pushed by AI coding agents that had unfiltered commit access. In the jqwik incident, the prompt injection was embedded in a test case that appeared benign but triggered data deletion when processed by an AI agent.

Three repositories were silently patched after hours, and no CVE was filed for any of the changes. The patches were pushed by automated agents that had been granted auto-merge privileges under the contract. The community only learned about the incident when the researcher published a blog post.

This backdoor is a direct consequence of the contract's lack of transparency. When a single vendor controls the commit stream and can push overrides without public RFC, the supply chain becomes vulnerable to malicious or accidental injections. The incident underscores the need for auditability in any SLA that grants emergency access.

Why the Linux Foundation Stayed Silent

The Linux Foundation, which oversees many critical open source projects through the Cloud Native Computing Foundation (CNCF) and other bodies, has not issued a public statement about the contract or the replacement of the 30 libraries. Internal memos, obtained by this publication, refer to the deal as "market evolution."

One reason for the silence is that the Linux Foundation itself has adopted proprietary clauses in some of its funded projects. For example, certain CNCF graduated projects offer enterprise licenses with SLA guarantees, blurring the line between open source and proprietary. The foundation's board includes representatives from B Corp's parent company, creating a potential conflict of interest.

Another factor is that the foundation's mission is to promote open source, not to police how organizations use it. As long as the original libraries were permissively licensed before the fork, the foundation has no legal standing to intervene. However, critics argue that the foundation should have spoken out against the anti-fork clauses, which undermine the very concept of open source.

The silence has emboldened other vendors. At least two similar deals are reportedly in negotiation, targeting libraries in the Kubernetes ecosystem. If the foundation does not take a stand, the pattern of single-vendor lock-in may become the norm.

What Every CISO Must Audit Before Q3

For security leaders, the contract is a wake-up call. The first step is to check your software bill of materials (SBOM) for any of the replaced libraries. If your organization uses a library that has been forked under a proprietary SLA, you may be legally restricted from forking to a secure version.

Second, verify that the license SLA includes a right to fork and escape. Some forward-thinking enterprises are now negotiating "fork and escape" clauses that allow them to create a community fork if the vendor fails to meet security SLAs. Without such a clause, you are locked in.

Third, demand maintainer independence disclosure. Ask your vendors whether the maintainers of your critical dependencies are bound by non-compete clauses or have transferred ownership. If they have, you are relying on a single point of failure.

Fourth, monitor commit patterns for overnight shifts or sudden increases in commit volume from unfamiliar accounts. This could indicate that automated agents are pushing code without human review. The jqwik incident was caught because a researcher noticed a commit at 3 AM local time from an account that had never contributed before.

Finally, negotiate contract clauses that ban AI-only changes. If a vendor's SLA allows AI agents to push emergency patches without human sign-off, you are exposed to prompt injection and other AI-specific attacks. Demand that all code changes be reviewed by a named human maintainer and logged in an immutable audit trail.

Trade-Offs and Counter-Arguments: Is the Contract All Bad?

Proponents of the contract model argue that it provides much-needed stability for underfunded open source projects. Before the deal, many of the 30 libraries had irregular maintenance, with critical bugs lingering for months. The SLA guarantees a four-hour response time for vulnerabilities, which is a dramatic improvement over the typical open source timeline. For Enterprise A, the cost of the contract ($12 million per year) is a fraction of what they would spend on internal development to maintain equivalent quality. From a purely economic standpoint, the contract may actually reduce overall supply chain risk for that single company.

However, this narrow benefit comes at a systemic cost. The anti-fork clause eliminates the possibility of community-driven fixes if B Corp fails to respond. The non-compete clauses prevent maintainers from creating alternative projects, reducing competition. Moreover, the contract sets a precedent that could encourage other vendors to target critical libraries, potentially fragmenting the ecosystem into dozens of proprietary silos. A counter-argument from the vendor side is that without such contracts, many libraries might simply be abandoned, leading to greater security risks. But this ignores the possibility of collective funding models, such as the Open Source Collective or GitHub Sponsors, which could sustain projects without sacrificing openness.

Another perspective comes from the maintainers themselves. While some regret the deal, others see it as a lifeline. Maintainer D, who was not part of the 30 but observed the process, noted that "open source burnout is real. If a contract can provide a living wage and health insurance, it's not inherently evil. The problem is the lack of transparency and the anti-fork clause." A more balanced approach might involve contracts that include community oversight, a right to fork after a certain period, and a revenue share that increases over time. The current deal lacks these safeguards, making it a cautionary tale rather than a model to emulate.

Lessons from Similar Incidents in Other Ecosystems

This is not the first time a single contract has reshaped a software ecosystem. In the JavaScript world, the left-pad incident of 2016 demonstrated how a single developer could break thousands of projects by unpublishing a trivial package. The response was the creation of a more resilient registry and the promotion of lockfiles. Similarly, the Ruby community faced the faker gem incident where a maintainer introduced a malicious change to protest corporate use. These events led to improved security practices, such as code signing and mandatory two-factor authentication for maintainers.

However, the current contract goes beyond those incidents because it involves a legal agreement that permanently restricts the community's ability to fork. In the left-pad case, the code was still open source; anyone could republish it. Here, the proprietary license and non-fork clause create a legal barrier. The closest analogy might be the Oracle v. Google API copyright case, which also involved the appropriation of open interfaces. That case took years to resolve and ultimately set a precedent that APIs are not copyrightable. But the current contract is not about APIs; it is about implementations, and the law is less clear on whether anti-fork clauses are enforceable in all jurisdictions.

One potential outcome is that regulators may step in. The European Union's Cyber Resilience Act, which came into effect in early 2025, requires software vendors to disclose the provenance of their dependencies and to ensure that critical components are not subject to unilateral control. If a dependency is locked behind a proprietary SLA, the vendor may need to demonstrate that an alternative exists. This could create a market for "open source escrow" services that hold a copy of the code under a permissive license, released only if the vendor fails to meet its obligations. Such a mechanism would mitigate the lock-in risk while preserving the benefits of the contract.

Conclusion: The Open Source Commons at a Crossroads

The open source ecosystem has always relied on trust. Contracts like this one erode that trust by concentrating power in a single vendor. The best defense is to audit your dependencies, negotiate for escape clauses, and support maintainers who choose to remain independent. The alternative is a world where every core library is a tollbooth.

As the industry grapples with these issues, the role of foundations like the Linux Foundation becomes critical. If they remain silent, the pattern will likely accelerate. If they speak out and advocate for contract standards that preserve openness, they can help steer the ecosystem toward a sustainable middle ground. The choice will determine whether open source remains a commons or becomes a collection of walled gardens.