Frontier AI labs are paying real money for real-world codebases to train their coding models. Pangea.ai works with a specialist licensing partner, who handles valuation, legal, and the sale end to end, so agencies in our network can turn dormant code into revenue. You're paid for every codebase that sells, with no upfront fee.

Frontier AI labs train and evaluate their coding models against genuine production code: the source and the git history behind it, how features were built, how bugs were fixed, how a project evolved over time. That kind of verified, real-world code is what's in short supply, and demand for it is high right now. The projects your agency has already delivered are exactly that, and because the history carries value too, you're paid for it, not just the final source.

Frontier AI labs and similar data buyers, all under confidentiality. Our partner packages and sells to them, so you never deal with the buyer directly, and specific buyers aren't disclosed.

Buyers license codebases to train, fine-tune, evaluate and benchmark their coding models, and to research and improve those models and the systems around them. They can modify the code and create derivative works for that work.

Our partner sets the terms of each buyer licence and negotiates them per deal (§6.3, §7.1), so the precise scope of any one licence is a commercial matter between our partner and that buyer, and its terms are confidential. Worth knowing: once a deal has closed, a buyer licence is perpetual and irrevocable on its own terms, and it isn't something you can revoke or unwind afterwards (§6.1, §7.3). Your warranties are passed through to buyers in substance, and they rely on them (§7.2).

You sign the agreement, connect GitHub, GitLab, or Bitbucket, and select the private repos you want assessed. Our partner checks, values, and grades each one. Once you've signed, every eligible repo is scrubbed, counted and presented to the labs right after analysis, whatever its grade. The labs choose what to license, so not every repo will be chosen. If a lab makes an offer, our partner concludes it on your behalf under the standing authorisation in §13.3, at the standing rates, and notifies you that your codebase is in a deal. The lab then raises a PO, typically on 60-day payment terms, and you're paid on Net 15 once the funds reach our partner.

Nothing on your side. While a lab reviews, usually 4 to 12 weeks, our partner works with it to prove the repo's training signal. These are planning ranges, not deadlines, and your dashboard shows where each repo sits.

A higher grade makes a repo more attractive to the labs, but it isn't a threshold, and the labs choose what to license, so not every repo will be chosen. What each lab wants shifts month to month.

Yes. You keep ownership, keep using the code, and keep shipping it to clients. You grant our partner a non-exclusive licence to access, package, market, license and sell the codebase to buyers, and you keep ownership of the code itself throughout (§6.2, §6.4). The licence is irrevocable while the agreement runs, and the one way to take a codebase off the table for future deals is the withdrawal right in §10.2 (see "Can we change our mind or pull a codebase?").

Two things sit outside that. If our partner acquires a codebase for its own account, or takes a licence to it for its own use, the position changes. See "Licence vs. buyout" below.

No. The licence you grant our partner is non-exclusive (§6.1), and §6.2 preserves your right to license, sell or transfer the codebase as a standalone asset yourself. In practice most agencies route everything through our partner, since that's where the buyer relationships and the packaging work sit.

There is one limit worth knowing. Under §11 you can't go around our partner to close a deal with a buyer our partner introduced you to, during the agreement or for twelve months after it ends, unless you can show you were already in documented discussions with that buyer beforehand. If you do, our partner is owed the full payment it would have earned. Buyers you found yourself are unaffected.

Yes. You keep the right to use, modify, and operate the codebase internally, and to keep using, maintaining, supporting, and deploying it for your existing and ongoing client engagements (§6.2). Nothing in the licence touches your own use of the code.

One thing to be aware of on our partner's side: to market and deliver a codebase, our partner may refine, correct, annotate and modify its own copy, and prepare packaged, redacted or white-labelled versions for sale (§6.1(a), §8). Your repositories are never written to; that work happens on our partner's copy.

The agreement already covers it. Under §12.2 you can assign the agreement to a successor in a merger, acquisition, or sale of substantially all assets, without our partner's consent; §10.1 then lets that successor terminate on 30 days' notice. So an acquirer can exit, and inherits nothing it can't walk away from. (Our partner can assign the agreement without your consent, and can sublicense and use subcontractors to exercise its rights.)

The licence travels with the agreement on a change of control, and ends whenever the successor chooses to terminate, on the same 30 days that applies to both sides. Two things survive that regardless: any buyer licence already granted, and anything our partner has licensed or acquired for its own account under §6.5.

On buyer licences specifically: one already granted survives on its own terms in every scenario, change of control or not. Where a buyer has licensed a codebase to train a model, that model is theirs. A deal already in the pipeline at the moment of the change of control can also still complete, and you're paid on it (§10.3).

Your side of the bargain is the ownership warranties, and they carry real weight, so it's worth reading §5 and §9 before you sign rather than after.

§5 asks you to warrant eight things about each codebase you submit: that you own it or hold sufficient rights to license it; that every founder, employee and contractor who touched it has assigned their IP to you; that no client or third party holds a conflicting right or is owed payment on a sale; that no third-party consent is needed; that it complies with its open-source and third-party licence terms, with no undisclosed copyleft or source-disclosure obligation; that it contains no malware; that it contains no personal data, third-party trade secrets, credentials or API keys except as disclosed; and that neither you nor it is caught by export controls or sanctions. Those warranties are treated as re-made every time one of your codebases goes into a deal (§13.9), you have a continuing duty to tell our partner promptly if any of them stops being accurate, and on reasonable request you'll provide redacted supporting documents (IP assignments, asset purchase agreements, prior licences) to evidence chain of title.

If a warranty turns out to be wrong, you indemnify our partner and, where warranties were passed through, its buyers, for the resulting claims and costs. On an infringement claim you'd be asked, at our partner's option and your expense, to secure the rights, replace or modify the affected code, or accept its removal and refund payments already received on affected licences (§9.3).

The asymmetry is worth naming. Your indemnity under §9.1 is not capped. Our partner's liability to you is: consequential and indirect losses are excluded, and its total liability is limited to what it actually paid you in the twelve months before the claim (§9.4). The platform, and every valuation, grade, score, token count and estimate on it, is provided as is (§9.5).

In practice this is why the guidance throughout is to submit only code you fully own, disclose your open-source position honestly, and flag anything client-owned or jointly owned early. The warranties are the part of this agreement with teeth.

There are four:

• Non-exclusive licences (the usual model). Our partner licenses your codebase to buyers non-exclusively, so the same repo can be licensed to more than one lab and you're paid each time, recurring, not one-off. These need no further signature from you: our partner negotiates and signs as principal under the authorisation in §13.3.
• Exclusive licence. One lab pays a premium for exclusivity on that codebase. This one does need your separate signed confirmation, and so does any deal that would cut into the rights you keep under §6.2 (§13.4).
• Our partner takes a licence for its own use (§6.5(a)). Distinct from the above, and worth reading properly. Our partner can take a perpetual non-exclusive licence to a codebase for its own account, by giving you notice and paying at the standing rates in force on the date of that notice, and it doesn't need your consent to do it. It can then build the code into its own products, services and datasets, use it to train and evaluate its own models, and create and commercialise derived data as its own property, with no further payment to you. That payment is full and final for those rights, and they survive termination of the agreement.
• Buyout, or exclusive acquisition (§6.5(b)). Our partner may offer to acquire a codebase outright, or take an exclusive licence to it, for a one-time payment negotiated in good faith. This one is entirely your call: it only happens at an amount you agree in writing. There's no further revenue share on that codebase afterwards, and you'd sign a short confirmation of the assignment so our partner can evidence chain of title.

The dividing line: for standard non-exclusive deals, our partner handles and concludes the commercial terms on your behalf without coming back to you. For an exclusive deal or an outright acquisition, nothing happens without your signature.

So far, repos have averaged 3.2 licences each. That's an average to date, not a promise: it varies with the quality, size, domain, history and buyer demand for a codebase, and no repo is guaranteed a number of licences. The standard model is non-exclusive, so the same repo can be licensed to multiple labs and paid for several times. Labs occasionally want exclusivity on a codebase, which pays a premium; you keep ownership either way.

Anything dormant or deprecated that you own: projects that have wound down, been rebuilt from scratch, or are simply sitting unused. Commit history, tickets, and documentation all add value.

In practice that means dormant client work you fully own, internal tools, and projects you rebuilt and left behind. Team-built repos with real history (multiple contributors, pull requests, tests) are worth the most. Skip client-owned IP you don't have the rights to license, anything that is or was public (including published packages), forks and renamed open source, copies of public templates, WordPress sites, themes and plugins, AI-written code, and single-file scripts.

Not sure about a repo? Submit it. Grading is free and private, nothing enters the pipeline unless you submit it, and nothing goes to the labs until you sign. Choosing what to submit is where your control sits.

Two things, and both have a dedicated field in the submission flow: (1) any open-source or third-party components, especially copyleft (GPL/AGPL/LGPL), which buyers warrant hard against; and (2) whether the repo has ever been public. That one is an eligibility check rather than a pricing input: buyers pay specifically for code that isn't already in a public training set, so a repo that is or was public can't be licensed, and flagging it early saves you submitting something that will be declined. Type or paste these in, or attach an SBOM. This gates listing, not signing; you can sign first and fill it in as you connect repos.

Yes. Only submit code you fully own, with no client claim, NDA restriction, or contributor owed payment on it. Client-owned code needs the client's written OK before it's submitted. You pick exactly which repos are included, and the ownership warranties you make are set out in §5 of your agreement: eight of them, re-made each time a codebase goes into a deal, and backed by an uncapped indemnity. See "What are we on the hook for if something goes wrong?" above before you submit.

No. Our partner scans and scrubs secrets and personal data from its own copy of the source and the full git history, and pseudonymises contributor identities before buyer delivery. You don't need to rebuild or manually anonymise anything, and your repositories are never written to.

So submit what you own as it is. The source is what's valued, and stripping code out yourself only lowers the number.

One thing to keep in mind: §5 of the agreement still asks you to warrant that a codebase contains no personal data, third-party trade secrets, credentials or API keys except as expressly disclosed. The scrubbing pass is our partner's process, not a substitute for that warranty, so if you know something sensitive is in there, disclose it rather than relying on the pass to catch it.

No. Buyers pay specifically for code that isn't already in a public training set, so a repository that is public today is an automatic decline, and so is one that was public at any point in the past, even if it's private now. An Internet Archive crawl of the repo page proves it was public on that date, and making it private afterwards doesn't undo that.

Forks of someone else's project, renamed open source, and code already published as a package (npm, PyPI or similar) are out for the same reason. Our partner also declines WordPress sites, themes and plugins, copies (the same code twice, or a public template with little new code on top), repos with no licensable source code, and AI-written code. Everything else you own and kept private is fair game. See the Eligibility tab for the full list.

One. Because of sanctions, our partner can't work with code owners resident in Russia, and can't pay them, whatever country their bank account is in. There's no other regional restriction.

It still goes to the labs. Once you've signed, every eligible repo is presented right after analysis, whatever its grade. A higher grade makes a repo more attractive to the labs; it isn't a threshold. You don't need to fix anything first, and your repositories are never written to.

It's the work data behind the code: tickets, docs, chats, support and CRM records, and AI assistant exports, linked to your repositories. Export it from the tools your team already uses, such as Jira, Linear, Notion, Confluence, Slack, Zendesk and HubSpot, and drop the file into the Operational data tab. Most exports take minutes.

Operational data is in beta. Names, emails and keys are scrubbed, files are deleted once read, and you review every link to a repository. It's being surfaced to the labs, with no quote, valuation or promise of payment yet, but it could add value to the same codebase.

See the full list of supported tools and export formats in Operational data on the Overview tab.

Yes, and it costs real money. History is priced in full and often carries the larger half of the value, so a squashed, shallow, single-commit or freshly re-initialised copy throws those tokens away. Connect the original repository straight from GitHub, GitLab or Bitbucket, with its pull requests, review, issues and tests kept on the host. If the code lives on your own machine in git, push that repository with its history; copying the files into a new repository resets every commit date to the upload day.

Yes. There's a downloadable estimator you can run against any repository on your own machine, before you connect a provider or sign anything. It uses the same counting rules and standing rates as the platform, and your code stays on your machine. Your Pangea.ai contact can send you the command.

It prices at the standing rates and prints an estimate, not an offer. Pass several repos, or a folder of them, for a row per repo and a total; it also prints the counting rule and the text it left out under each one, so a small number explains itself.

GitHub, GitLab, and Bitbucket; you can connect more than one.

As little as you want to give, and read-only. You choose which repositories: connecting GitHub installs our partner's app on the repos you select, with read-only access to code, metadata, pull requests and issues in those repositories. Connecting makes repositories available to pick; only the ones you submit are copied for analysis. You can change that list, or remove our partner entirely, from your GitHub settings at any time.

Our partner scrubs, values and grades its copy of what you submit, and never writes to your repositories. Nothing you don't select is touched. The same applies on GitLab and Bitbucket: access is scoped to the repos you pick, and revocable at your provider any time.

A few minutes to connect and see estimates. You can submit several repos at once and add more any time.

First, a low grade isn't a rejection: every eligible repo goes to the labs once you've signed, whatever its grade. Nor is a "Low likelihood of licensing" flag: context with something verifiable can clear it. An outright decline is a different thing: a repo that is or was public, a published package, a fork or renamed open source, a copy, a WordPress site, theme or plugin, AI-written code, a repo with no licensable source code, or client-owned or third-party code you don't have the rights to license. A decline never affects your other submissions, and where reasonable our partner explains the reason.

Two things to be straight about. Our partner is under no obligation to accept, list, market or sell any codebase, and can decline, defer, remove or discontinue one at its own discretion (§4, §13.10). There's no minimum number of deals, no minimum revenue and no guaranteed listing period. It can also suspend or remove a codebase immediately where it reasonably judges there's an infringement, malware, undisclosed personal data or credentials, a legal, security or reputational risk, or a third-party claim; you get prompt notice and, where practicable, a chance to fix it.

Our partner does. The NDA and licence are one combined agreement, already countersigned; you sign once, and can download your copy any time.

You can also read it before you sign anything: ask your Pangea.ai contact for a copy of the current Codebase Agreement and send it to whoever needs to review it. The signing page shows the same document, and your signed copy sits on that page afterwards.

Yes. Your team joins under one organization, everyone connects their own Git accounts, and repos and payouts roll up in one place. No duplicate accounts needed.

Our partner doesn't pre-filter by grade: once you've signed, every eligible repo goes to the labs, and the labs choose what to license. Repos flagged "Low likelihood of licensing" wait until they're cleared. Each repo is graded first. A model reads the cleaned copy and scores architecture, tests, documentation and history against a fixed rubric, then gives it a letter grade. A higher grade makes a repo more attractive; it isn't a threshold. A repo is never built or run to be graded.

Valuation counts genuine source code at the current head plus useful code in the git history. Markup, data, config and docs count up to 10× the code beside them. Generated files, vendored dependencies, build output, binaries, archives and data dumps don't count as source, so padding a repo doesn't lift its number. Third-party code copied straight into your source folders stays in, under its own licence, so disclose it.

The whole repo is assessed as one codebase, including its genuine source and full git history. If several people contributed to the same project, their combined work and history are assessed together. Team-built projects are generally more attractive to labs than solo ones, because they carry richer collaboration signals: multiple contributors, pull requests, reviews, bug fixes, and a more meaningful development history. Individual repos can still be submitted, but genuine team projects are more likely to attract buyer interest. If important code lives only on separate, unmerged branches, confirm with your Pangea.ai contact how those branches will be handled before submitting.

Only the repos you choose. Repos you don't pick are never copied, and you can revoke access at your provider any time.

What you do submit can be seen by our partner and the service providers involved in preparing it, and by prospective buyers under written confidentiality obligations. A model reads the code during grading. This is confidential licensing, not publishing your repository as open source.

The agreement also permits disclosure to a defined set of others: affiliates and sublicensees, infrastructure and data-room providers, financing sources in a corporate transaction, and vetted prospective buyers, each bound by confidentiality at least as protective as your own. The Code Handling & Security tab sets out the full list.

Yes. Both sides are under mutual confidentiality; access is limited to people with a need to know who are bound by equivalent terms, and our partner won't expose your code publicly except as needed to market or deliver it to a buyer under confidentiality or licence. Confidentiality obligations run for five years from disclosure (longer for trade secrets, which stay protected as long as they remain trade secrets). If either side becomes aware of unauthorised access or disclosure, it must notify the other in writing within 72 hours and cooperate on investigating and remediating it.

The existence and terms of the relationship aren't disclosed publicly without your consent, and any buyer is bound by a confidentiality obligation or licence before seeing the code. The scrubbing pass also pseudonymises contributor identities across the code and the git history, so the commit trail doesn't carry your team's names to a lab.

Yes, on two levels. In the product, you can remove any codebase yourself, at any point before it's licensed; it hard-deletes the stored copy, with no notice needed. Contractually, §10.2 gives you a withdrawal right on 30 days' written notice, and either party can end the whole agreement on 30 days' notice (§10.1).

What withdrawal doesn't reach, so there are no surprises: a buyer licence already granted; an active, documented buyer transaction or negotiation already in progress when you give notice, or that starts during the 30 days (a "Pipeline Transaction"); our partner's right to keep administering licences already out there; and anything our partner has licensed or acquired for its own account under §6.5. For 90 days after termination or withdrawal (the "Tail Period"), our partner can still close those pipeline deals, and you're paid on them on the normal terms. During that window you agree not to approach the buyers involved directly (§10.3).

On written request, our partner returns or destroys your codebase and related confidential information. That's subject to what it must keep by law, what sits in routine archival or backup, what it needs to honour buyer licences already granted, and anything under §6.5, all of which stays covered by the confidentiality terms (§10.5). In practice, on request our partner deletes every stored copy of the code and confirms in writing. No separate backups of code are kept; what remains is the repository record in the database's rolling backups until they expire, and a short removal record (name, grade, value, reason, date).

Access is read-only and limited to the repositories you select. Our partner works on a separate copy: it scans and scrubs secrets and personal data from that copy of the source and git history, removes vendored dependencies, build output, compiled packages and archives from every commit, and pseudonymises contributor identities before buyer delivery. A model reads the cleaned copy to grade it against a fixed rubric; grading never builds or runs the code.

Code travels over HTTPS and is encrypted at rest. Prospective buyers see it only under written confidentiality obligations, and any licence is on the terms our partner agrees with them. See the Security tab for the detail.

Yes, it can stay completely non-public. The relationship, your identity as the code owner, and the commercial terms aren't disclosed publicly, and buyers are bound by confidentiality before they receive any code. You keep ownership under a standard licence and can carry on using, modifying, and deploying the code. If the codebase or the company behind it is later sold, existing licences may need to be disclosed privately during legal due diligence, but they never have to be announced publicly.

The rates are written into the agreement itself. §13.2 sets standing rates of $100 per million source tokens and $40 per million git-history tokens, and states that's the basis on which our partner expects to pay for a standard non-exclusive licence. Our partner can change them on 30 days' notice, and a change never affects a licence already granted; a deal is paid at the rate in force when it was granted.

Two honest caveats. The standing rates are not a fixed price, a minimum, or a guarantee for any particular deal: where a transaction's terms differ from a standard non-exclusive licence, our partner may set a different amount, acting reasonably and in good faith, and will tell you that amount at or before payment. And the token count the rate is applied to is determined by our partner's own analysis (§4), which decides what's counted and what's excluded.

There is no per-deal sign-off on a standard licence. Your signature on the agreement is standing authorisation for each non-exclusive buyer licence our partner grants (§13.3); you're notified on the platform or by email when one of your codebases is included in a deal (§13.9). A separate signed confirmation is required only for an exclusive licence, a deal that would restrict the rights you keep under §6.2, or (at our partner's option) a deal priced off the standing rates (§13.4). Your control over whether a codebase is offered at all is the withdrawal right in §10.2.

Payment is owed once a deal closes: the buyer licence is signed and our partner has the first cleared, non-refundable funds in hand (§13.5). It's paid out of what our partner actually receives for that deal and never more than that. If a buyer's payment is later refunded, charged back or clawed back, our partner can recover the proportionate amount from future payments, and it can net off anything you owe it under the agreement.

There's no upfront fee: connecting, submitting and grading cost nothing, and there's no obligation to submit anything. The standing rates are the basis for your payout, not a buyer price from which a platform commission is deducted. Pangea.ai is compensated separately by our partner, so nothing comes out of your payout for us. Receiving-bank or currency-conversion fees and taxes are yours.

You're paid on Net 15 terms: within 15 days of our partner receiving payment from the buyer. Labs typically raise a PO on around 60-day terms, so that's the wait before funds reach our partner; once they do, your Net 15 clock starts. Where a buyer pays in instalments, a proportionate part of your payment accrues as each one lands. Payout details go in your dashboard, and you're paid in US dollars by ACH or wire to the account you designate and verify there.

Two practical conditions. Our partner needs your tax documentation on file (a W-9, or a W-8BEN / W-8BEN-E if you're outside the US) along with a verified payout account, and can hold payment until both are in place (§13.7). Where law requires tax to be withheld, it's withheld and remitted, and you get the form showing it. Receiving-bank and currency-conversion charges are yours. Payment is made to your business as income.

Your dashboard carries a record for every buyer licence covering one of your codebases: the codebases included, the licence type, the amount you're paid, and the date paid (§13.8), plus funnel status and your total earned.

Two things are outside it. The buyer's identity and the terms of their licence are confidential, and you're not entitled to an accounting of what our partner received from the buyer, so the record shows your payment, not the deal's economics. Where a single deal covers codebases from more than one owner, or is priced as one figure across several codebases, the consideration is split across them in proportion to their total token counts (§13.5).