Code is among the most valuable training data in the market, and the estates holding it — GitHub organizations, Snowflake and Databricks accounts, internal platforms — were built for engineering, not for sale. The gap between holding a valuable asset and being able to license it is where most of these conversations end.
What the asset actually is
"Codebase" undersells it. The licensable estate is usually wider than the source files themselves.
| Where it lives | What has value |
|---|---|
| Source repositories GitHub, GitLab, Bitbucket |
Production code across languages and eras, commit history showing how problems were solved over time, code review threads, issue and pull request discussion, test suites paired with the code they verify. |
| Data platforms Snowflake, Databricks, BigQuery |
Schemas and data models, transformation logic and pipeline code, query histories showing how analysts actually interrogate a domain, documented metric definitions. |
| Engineering surround | Internal documentation, runbooks, architectural decision records, incident post-mortems, API specifications and their change history. |
The paired material is often worth more per token than the code. A commit that fixes a bug, attached to the issue describing the bug and the test proving the fix, is a complete worked example — and complete worked examples are scarce.
Why buyers want it
Three reasons, and they are not the same reason.
Code teaches reasoning. Model developers have found that training on code improves performance on tasks that have nothing to do with programming. Code is structured, verifiable, and unambiguous in a way most text is not.
Agentic coding is where the competition is. Systems that write and modify software are the most commercially contested capability in the market. Training them requires not just code but the surrounding record of how code changes — which is exactly what repository history is.
Domain-specific estates are scarce. Public open-source code has been thoroughly harvested. Proprietary code in a specialized domain — broadcast systems, ad serving, rights management, streaming infrastructure — represents patterns that do not exist in public repositories at any volume.
A platform estate like Snowflake carries a different value: schemas and query histories encode how a particular industry structures and reasons about its data, which is useful well beyond the code itself.
What blocks a deal
Most codebases are not cleanly licensable on day one. These are the issues that surface in diligence, roughly in the order they kill deals.
- Open-source license contamination. Copyleft licenses such as the GPL and AGPL carry obligations that can extend to derivative work. A repository with copyleft code mixed into proprietary code may be unlicensable until the two are separated — and the separation is often non-trivial.
- Third-party dependencies. Vendored libraries, SDKs, and purchased components sit inside most repositories and are not yours to license onward.
- Contributor chains. Code written by contractors, agencies, acquired teams, or employees in jurisdictions with different work-for-hire rules may not be owned as cleanly as the organization chart implies. Missing contributor agreements from years ago are a common dead end.
- Customer data in the estate. Platform accounts frequently contain customer records, and client contracts rarely contemplate onward licensing. Schemas may be licensable where the rows inside them are not.
- Secrets and credentials. Repository history routinely holds API keys, tokens, and connection strings committed and later removed — still present in history, and a security incident if shipped.
- Personal data in commits. Author names, emails, and review comments are personal data under the GDPR and comparable regimes, with implications for any transfer.
- Competitive exposure. Licensing code that encodes genuine operating advantage is a strategic decision, not just a commercial one. Some of the estate should not be sold at any price.
None of these are reasons not to pursue a deal. They are reasons to establish your position before entering a negotiation rather than during one. Counterparties run thorough diligence, and discovering a contamination problem after terms are agreed costs both the deal and the relationship.
How these deals get structured
- One-time corpus license. A defined snapshot licensed for a fixed fee. Simplest to execute, and leaves future value on the table.
- Refresh arrangements. Initial corpus plus periodic updates. Higher total value, and requires an ongoing pipeline and governance commitment.
- Field-of-use limited. Licensed for specified purposes, with other uses reserved. Preserves optionality and narrows the buyer pool.
- Exclusive or semi-exclusive. Commands a premium, forecloses other buyers, and is usually the wrong first deal.
Terms worth more attention than headline price: whether outputs of models trained on your code are restricted, whether the buyer may sublicense, what happens at termination, audit rights, and how attribution and confidentiality are handled.
What to do first
Before any counterparty conversation:
- Scan for licenses and dependencies across repositories, so you know what is clean and what is contaminated.
- Map contributor provenance and identify where agreements are missing.
- Separate the estate into what is clearly licensable, what needs remediation, and what is strategically off limits.
- Scrub secrets and personal data from history, not just from the current state.
- Establish a valuation position grounded in comparable transactions, so you negotiate against a number rather than react to one.
How we engage
We work with leadership and engineering to establish what the estate contains, what can be licensed, what it is plausibly worth, and how to approach the market — then support the commercial process through to terms, alongside your counsel.
Rights determinations are legal questions. Our role is commercial and strategic; conclusions about ownership, license compatibility, and permissible transfer must be confirmed by qualified counsel. See our Disclaimer.
Discuss your codebase or platform estate