The direct answer: most open AI models can be used commercially, and the exceptions are exactly where startups get hurt. 'Open source' on a model card is a marketing phrase. The legal reality lives in a license file, and in AI stacks there are three of them: one on the code, one on the model weights, and often one on the dataset. Each layer can carry different terms, and the strictest one wins.
This guide reads those layers the way a diligence team will: which licenses are genuinely permissive, which reach into your product, and which restrictions founders discover only when an acquirer's counsel asks for the license inventory nobody kept. It extends the ownership analysis in who owns your startup's code to the AI-specific stack.
The three license layers in every AI stack
- Code. Inference frameworks, fine-tuning tooling, orchestration libraries. Ordinary open-source licenses apply: MIT, Apache 2.0, BSD, GPL family.
- Weights. The trained model itself. Sometimes a standard license (Apache 2.0 on many Mistral and Qwen releases), often a custom 'community license' (Meta's Llama), occasionally research-only terms that quietly prohibit commercial use.
- Data. Training and fine-tuning datasets carry their own terms, from Creative Commons variants to research-only restrictions, and non-commercial dataset terms can contaminate what you built with them.
The failure mode is checking one layer and assuming the rest. A permissively licensed framework running research-only weights is not a commercial stack.
Reading the license families: what commercial use permits
MIT and BSD: nearly frictionless. Attribution and license-text preservation, and that is roughly it. Commercial use, modification, and proprietary derivatives are all fine.
Apache 2.0: the commercial workhorse. Everything MIT gives, plus an express patent grant from contributors, which is why it is the license enterprises like to see in a stack. Requirements are notices and a statement of changes. Models under Apache 2.0 are the closest thing to a safe default for unrestricted commercial building.
GPL and AGPL: copyleft, and the network trap. GPL requires derivative works you distribute to carry the same license. AGPL extends that to software served over a network, which is precisely what a SaaS product does. Modified AGPL components inside a hosted product can trigger an obligation to offer your source. Diligence teams search for AGPL by name; treat it as a decision, never an accident.
Community licenses: read the actual text. Llama-style licenses permit most commercial use while attaching conditions that matter: acceptable use policies, attribution and naming rules for derivatives, restrictions on using the model or its outputs to improve other models, and scale thresholds (Meta's requires a separate license above 700 million monthly active users). None of this usually blocks a seed-stage launch. All of it belongs in your records, because your enterprise customers' AI addenda and your acquirer's counsel will ask.
Nobody loses their company to a license they read. The damage comes from the dependency nobody logged, found by someone else's counsel at the worst possible time.
Where this bites: procurement and diligence
License compliance is invisible until a third party makes it visible. Enterprise buyers now ask which models power the product and under what terms, as part of the same review covered in the enterprise AI sales checklist. Investors and acquirers run automated scans plus counsel review, and the findings that reprice deals are predictable: AGPL in the serving path, research-only weights in production, a fine-tune built on a dataset whose terms prohibit commercial use, and Llama derivatives missing the required attribution. Every one of these is cheap to fix or avoid early and genuinely expensive to unwind late, which is the same asymmetry that runs through the whole diligence checklist.
The practical playbook
- Keep a license inventory. One document: every model, framework, and dataset in the stack, its license, and the date you checked. An hour a quarter, and it converts diligence from an excavation into a printout.
- Default to permissive for the serving path. Apache 2.0 and MIT components for anything that runs in production; treat copyleft anywhere near the product as a deliberate, reviewed exception.
- Read community licenses once, properly. Note the acceptable use policy, naming rules, output restrictions, and thresholds. Set a reminder to re-check when versions change, because these licenses change with them.
- Check dataset terms before fine-tuning. The model you produce inherits questions from the data that shaped it, the same chain-of-title logic as AI-generated content ownership.
- Mirror the position in your own terms. What you promise customers about your stack should match what your licenses actually permit you to promise.
- 'Open source' on a model card is marketing; the license text on code, weights, and data is the law of your stack, and the strictest layer wins.
- MIT and Apache 2.0 are safe commercial defaults; Apache adds the patent grant enterprises like.
- AGPL can force source disclosure for hosted products; treat it as a deliberate decision only.
- Community licenses (Llama) permit most commercial use with real conditions: AUPs, naming, output restrictions, scale thresholds.
- Keep a license inventory; diligence teams will build one either way, and theirs arrives with consequences.
The strategic read: open models are one of the great cost advantages available to AI startups, and the license work that makes them safe is measured in hours. Do the reading before you build, log what you use, and the advantage stays an advantage all the way through your exit.
Related reading: who owns your startup's code, the AI startup legal checklist, and the due diligence checklist. Or start a conversation about your license inventory.