But Is It Open?The online edition
Type & theme

Make yourself comfortable

Page color
Text size
20 px
Reading width
Ask about this chapter ↗

Your settings and place stay in this browser.

Chapter 15 · Timothy O’Brien

The Terms That Travel with the Weights

8 minute read19 source notesFree online edition

A model file can stay exactly the same while the terms on its download page change. A license may link to a policy hosted somewhere else, and that page may change on its own schedule. A repository commit preserves the files in that repository. It doesn’t preserve the website around them.

Whether later terms govern a copy you already have depends on the agreement and the law. A changed page does not, by itself, rewrite an existing grant. But if you return for another checkpoint, accept new access terms, or offer a hosted service, you may enter a different arrangement. Keeping the weights without keeping the terms leaves you with only half a record.

The bundle is wider than the license file

Pull a model from a repository and you usually see a license file or a link on the model card. Start there, then check what else governs the transaction:

  • the model card and the artifact license
  • any acceptable-use policy incorporated into that license
  • separate terms accepted to obtain access
  • platform, developer-program, API, or marketplace agreements
  • redistribution, attribution, and naming rules
  • termination, governing-law, and forum clauses

These documents do different jobs. A model card describes a release. A copyright license grants permissions subject to conditions. An access agreement may impose additional contractual promises. A publisher’s policy statement does not automatically become a condition of every license beside it.

An Apache-licensed inference engine doesn’t make the weights Apache-licensed, and Apache-licensed weights don’t relicense the training data. Name the component and the agreement before drawing a conclusion.

Clauses worth reading twice

The examples here describe public texts checked in November 2026. They show what to look for; a deployment decision still needs the exact release and agreement.

Start with thresholds. Meta’s Llama 4 license says that if you or your affiliates had more than 700 million monthly active users in the month before its April 5, 2025 release, you must request a separate license. Until Meta grants it, at its sole discretion, you have no rights under that agreement. The license also incorporates an Acceptable Use Policy and requires “Built with Llama” branding in specified circumstances.1

Alibaba’s custom license for Qwen2.5-72B sets a separate-license threshold at 100 million monthly active users for commercial use.2 Mistral’s Devstral 2 carries a modified MIT grant that withholds rights when a company’s consolidated monthly revenue exceeded $20 million in the preceding month.3 Moonshot’s Kimi K2 condition is different: above 100 million monthly active users or $20 million in monthly revenue, a product must prominently display the model name.4 A display obligation and a requirement to negotiate permission are materially different restrictions.

Terms also move between releases. Qwen3’s cited 235B checkpoint uses Apache 2.0.5 Zhipu’s 2024 GLM-4 license required commercial registration; GLM-4.5 and GLM-5 use MIT. Later, GLM-5.3 introduced a custom security-review condition for qualifying large Model-as-a-Service operators, while GLM-5.3 Flash retained MIT.6 A familiar family name cannot stand in for reading the next license.

Policies incorporated by reference deserve particular attention. Earlier Gemma terms incorporate Google’s Prohibited Use Policy, reserve a right to restrict usage “remotely or otherwise,” require restrictions to pass downstream, and provide for termination. The same page directs Gemma 4 users to a different license. Copying the old terms without the incorporated policy would leave the record incomplete; applying them to every Gemma release would also be wrong.7

OpenAI’s gpt-oss provides a useful contrast. Its weights use Apache 2.0. The separate usage-policy file asks for compliance with applicable law; the Apache text does not incorporate a Gemma-style prohibited-use list.8 The existence of a policy file alone tells you little. Read its words and determine whether you separately accepted any obligations.

Apertus 1.5 70B shows why this distinction matters. The weights are identified as Apache 2.0, but the publisher’s Hugging Face download requires assent to a separate AUP. That agreement adds an indemnity to ETH Zurich and EPFL and requires redistributors to obtain recipients’ express assent, with the obligation passed along again. The artifact license and the access contract need separate entries in a review.9

Finally, check which way an indemnity runs. A vendor’s promise to cover certain claims against a customer is different from Apertus’s requirement that the user protect the institutions. OpenAI’s service terms offer an output indemnity for covered customers, with exclusions including knowingly infringing use, ignored safeguards, modified or combined outputs, and insufficient rights to inputs or fine-tuning material.10 Anthropic and Google Cloud have described protections for covered commercial use too.1112 Those promises live in service contracts. A person running downloaded weights may have no equivalent protection.

Possession, access, and permission

Downloading gets you a copy. Three questions remain: can you obtain it again, can you keep running it, and may you?

Future access depends on the platform and publisher. Hugging Face authors can reject or cancel approvals for gated models.13 Running a local copy requires the actual weights, tokenizer, configuration, and necessary code. Legal permission depends on the agreements. Losing platform access doesn’t by itself terminate a license; holding a file doesn’t guarantee permission after a valid termination.

Distribution often triggers obligations that private use does not. Apache 2.0, for example, requires redistributors to include the license, preserve relevant notices, and identify modified files.14 Model agreements may also attach conditions to hosting, fine-tuning, or naming a derivative. Describe the act you intend to perform before deciding which clause applies.

What to keep alongside the weights

My starting suggestion was to screenshot whatever you agreed to. The research led to a more useful record: the artifact, the complete terms, and the transaction that connected them.

  1. Capture the transaction. Save the download page, consent wording, linked agreements, and confirmation. Record the URLs, date, time zone, account, and whether you accepted for yourself or an organization. Keep approval emails and separately negotiated permissions.
  2. Keep complete documents. Save the license, incorporated policies, access agreement, notices, and model card as readable HTML or PDF. A link is not an archive of an external page.
  3. Identify the artifact. Record the publisher, repository, variant, full commit ID, filenames, and acquisition date. Document conversions or quantization. Hugging Face supports downloads pinned to a full commit hash.15
  4. Keep a usable copy where permitted. Include weights, tokenizer, configuration, required code, and runtime versions. Test it offline. A downloader script or a partial cache is not the model.
  5. Make integrity records. Generate SHA-256 fingerprints for the files and documents, and store a copy of the manifest separately with a backup. NIST recommends hashing and separate storage of hash values; SWGDE recommends contemporaneous collection notes and interface screenshots.1617 Your hash can reveal a later change. It does not establish where the original file came from.
  6. Record continuing obligations. Write down attribution, redistribution, threshold, termination, and jurisdiction clauses in plain language, with links to the saved text. Preserve later notices as new records.

A screenshot is evidence of what you saw, not a permanent permission slip. Keep account records private, omit access tokens from shared records, and remember that permission to archive gated weights is not permission to publish them.

Following one release into a product

Consider a hypothetical team building an assistant for its own support staff. It starts with Qwen3-8B, running locally against documents the organization controls. That is a specific checkpoint under Apache 2.0, not an approval of every model carrying the Qwen name.18 The first useful record is correspondingly small: what the team obtained, where it came from, which revision it selected, and which terms governed that acquisition.

The engineer saves the repository identifier and full revision, the license and model card, and any separate acceptance screen encountered during the download. A copy of the runtime configuration records how the files were loaded. The file manifest covers the weights, tokenizer, configuration, and saved documents. Keeping that manifest elsewhere gives a later engineer a way to detect a changed or incomplete copy.

An offline test then answers a technical question: can this particular collection of files run without calling a service the team forgot it depended on? Passing the test would not establish that the software is secure or that the organization has every necessary right. It would establish that the retained artifact and runtime are usable independently. A licensing record and an operational test support different conclusions.

A month later, suppose the team proposes offering the assistant to customers. The model files may be unchanged, but the system is different. Customer data will enter it. Outputs will leave the organization. Logging, retention, access controls, and the agreements with customers need decisions of their own. The existing record lets the team ask those questions about a known component instead of first reconstructing what somebody downloaded.

There is a second possible change: shipping the weights or a modified checkpoint to a customer. That is a distribution question. Apache’s ordinary license, notice, and modified-file requirements now need to be followed for the covered material.14 The model license does not grant rights to every document used for fine-tuning, erase duties concerning personal data, or warrant that every output is safe to publish. Those remain separate parts of the review.

Now suppose a benchmark tempts the team to replace the 8B checkpoint with Qwen3.8-Max. The provider’s name has not changed, but the license has. The Max text includes display and separate-license thresholds, with definitions and exceptions that must be read against the actual business.19 The earlier Apache review cannot approve that substitution. The engineer creates a new acquisition record and describes the proposed service, including whether it is internal, customer-facing, or itself selling model access.

The same applies if the team chooses a hosted endpoint instead. Its local copy and offline test say little about that provider’s retention policy, service agreement, or indemnity. The endpoint is another component with another relationship to record.

None of this scenario supplies a legal outcome. It shows what the record buys: the team can distinguish a new deployment from a new license, an artifact from a service, and a retained copy from continuing permission. When a question needs counsel, it can bring a concrete system and a dated set of documents rather than a screenshot of the word “open.”

For a consequential use, this record gives counsel something concrete to analyze: the component, the intended act, the grant, and the promises accepted alongside it. It also lets the engineering team reproduce its own decision when the download page changes.

Keeping this record is engineering work. Understanding which promises bind the organization requires the legal background in the next chapter.

Notes

  1. Meta Platforms, “Llama 4 Community License Agreement,” Llama 4 Version Effective Date April 5, 2025, https://github.com/meta-llama/llama-models/blob/main/models/llama4/LICENSE. Definitions of “Llama Materials”; section 1.b.i (“Built with Llama” display and “Llama” model-name prefix); section 1.b.iv (Acceptable Use Policy incorporated by reference); section 2 (700 million monthly active users, license granted “in its sole discretion”). ↩

  2. Alibaba Cloud, “Qwen LICENSE AGREEMENT,” release date September 19, 2024, section 4 (separate license above 100 million monthly active users for commercial use), Qwen2.5-72B-Instruct repository, Hugging Face, https://huggingface.co/Qwen/Qwen2.5-72B-Instruct/blob/main/LICENSE. ↩

  3. Mistral AI, “Modified MIT License,” Devstral-2-123B-Instruct-2512 repository, Hugging Face, https://huggingface.co/mistralai/Devstral-2-123B-Instruct-2512/raw/main/LICENSE. Condition 2 withholds all rights if the global consolidated monthly revenue of your company or employer exceeded $20 million in the preceding month. Mistral’s help center says “certain models” use this license and that Apache 2.0 covers most of its open models: Mistral AI, “Under which license are Mistral’s open models available?,” https://help.mistral.ai/en/articles/347393-under-which-license-are-mistral-s-open-models-available. ↩

  4. Moonshot AI, “Modified MIT License,” Kimi-K2 repository, GitHub, 2025, https://github.com/moonshotai/Kimi-K2/blob/main/LICENSE. ↩

  5. Qwen team, Alibaba Cloud, LICENSE (Apache License, Version 2.0), Qwen3-235B-A22B repository, Hugging Face, https://huggingface.co/Qwen/Qwen3-235B-A22B/raw/main/LICENSE. ↩

  6. Zhipu AI / THUDM, “The glm-4-9b License,” https://huggingface.co/THUDM/glm-4-9b-chat/raw/main/LICENSE (commercial registration); Z.ai, GLM-4.5, https://huggingface.co/zai-org/GLM-4.5, and GLM-5, https://huggingface.co/zai-org/GLM-5 (MIT); Z.ai, GLM-5.3 License, https://huggingface.co/zai-org/GLM-5.3/raw/main/LICENSE (security review for qualifying Model-as-a-Service operators above $10 billion aggregate revenue over any consecutive twelve months); release description, https://z.ai/blog/glm-5.3 (MIT retained for Flash). Checked November 15, 2026. ↩

  7. Google, “Gemma Terms of Use,” last modified April 1, 2026, https://ai.google.dev/gemma/terms. Section 3.1 (distribution conditions, including passing on the section 3.2 use restrictions); section 3.2 (Prohibited Use Policy at https://ai.google.dev/gemma/prohibited_use_policy incorporated by reference, and the right to restrict “(remotely or otherwise)” usage Google reasonably believes violates the agreement); section 4.5 (term and termination). The page states that it covers the Gemma models listed in its appendix and points to a separate Gemma 4 license. ↩

  8. OpenAI, “Introducing gpt-oss,” August 5, 2025, https://openai.com/index/introducing-gpt-oss; gpt-oss-120b LICENSE, https://huggingface.co/openai/gpt-oss-120b/raw/main/LICENSE, and USAGE_POLICY, https://huggingface.co/openai/gpt-oss-120b/raw/main/USAGE_POLICY, checked November 15, 2026. The policy asks users to comply with applicable law; the Apache license does not incorporate a separate prohibited-use list. ↩

  9. Swiss AI Initiative, Apertus-v1.5-70B model page and download assent, https://huggingface.co/swiss-ai/Apertus-v1.5-70B; “Apertus LLM Acceptable Use Policy,” v1.5, July 14, 2026, https://github.com/swiss-ai/apertus-legal/blob/main/apertus_1.5/USAGE_POLICY.pdf. The AUP requires indemnification and downstream express assent to its obligations. These are additional contractual promises; the model page identifies the artifact license as Apache 2.0. Checked November 15, 2026. ↩

  10. OpenAI, “Service terms,” updated October 16, 2026, sections 1(a) and 3(b), https://openai.com/policies/service-terms. ↩

  11. Anthropic, “Expanded legal protections and improvements to our API,” December 19, 2023, https://www.anthropic.com/news/expanded-legal-protections-api-improvements. ↩

  12. Neal Suggs and Phil Venables, “Shared fate: Protecting customers with generative AI indemnification,” Google Cloud blog, October 12, 2023, https://cloud.google.com/blog/products/ai-machine-learning/protecting-customers-with-generative-ai-indemnification. ↩

  13. Hugging Face, “Gated models,” Hub documentation, https://huggingface.co/docs/hub/models-gated. ↩

  14. Apache Software Foundation, “Apache License, Version 2.0,” January 2004, section 4 (Redistribution), https://www.apache.org/licenses/LICENSE-2.0. ↩1 ↩2

  15. Hugging Face, “Download files from the Hub,” huggingface_hub documentation, https://huggingface.co/docs/huggingface_hub/main/en/guides/download. The guide notes that a commit hash passed as a revision must be the full-length hash. ↩

  16. Barbara Guttman, Douglas R. White, and Tracy Walraven, “Digital Evidence Preservation: Considerations for Evidence Handlers,” NIST IR 8387, National Institute of Standards and Technology, September 2022, https://nvlpubs.nist.gov/nistpubs/ir/2022/NIST.IR.8387.pdf. ↩

  17. Scientific Working Group on Digital Evidence, “Best Practices for Digital Evidence Collection,” SWGDE 18-F-002-2.0, version 2.0, approved November 18, 2025, released November 20, 2025, section on documentation (“Detailed collection notes should be contemporaneously created,” including “screenshots of the interface”), https://swgde.org/wp-content/uploads/2025/12/2025-11-20-Best-Practices-for-Digital-Evidence-Collection-18-F-002-2.0.pdf. ↩

  18. Qwen team, Qwen3-8B LICENSE, Apache License 2.0, https://huggingface.co/Qwen/Qwen3-8B/raw/main/LICENSE; model card, https://huggingface.co/Qwen/Qwen3-8B. The scenario is hypothetical and illustrates recordkeeping, not a reported deployment. ↩

  19. Qwen team, Qwen3.8-Max License, https://huggingface.co/Qwen/Qwen3.8-2.4T-A95B/raw/main/LICENSE. The display and separate-license conditions have distinct thresholds and include an internal-use exception; assess the actual proposed use against the exact text. ↩

From But Is It Open? by Timothy O’Brien (Discursive, 2026). © 2026 Timothy O’Brien. All rights reserved.

Chapter 158 min leftNext →

The book, chapter by chapter.

Source note

Go to the notes & sources ↓

The vocabulary.

A short guide to the book’s recurring terms. Follow each chapter for the argument and its sources.

Open weights
A release makes a trained model’s learned parameters available. The accompanying terms decide what you can do with them. Access to weights alone does not provide the training data, code or recipe. Read the chapter →
Copyleft
A way of using license conditions to preserve recipients’ freedoms when covered software is passed on. The obligations depend on the license and on what you distribute or make available. Read the chapter →
Permissive licenses
Licenses such as MIT and Apache 2.0 grant broad reuse rights with comparatively few conditions. Notice obligations still apply, and a software license does not automatically cover a release’s data or other components. Read the chapter →
Reproducibility
The ability to reconstruct and examine how an artifact was produced using the resources that are published. Running an existing checkpoint is a different achievement from rebuilding its training. Read the chapter →
Governance
Who can participate, who makes decisions, and how authority over a project or release is shared. A right to use the code does not by itself create a voice in upstream decisions. Read the chapter →
Training data
The examples used to train a model. Publishing the data, documenting its provenance and describing how it was filtered are distinct kinds of disclosure; privacy and other rights may limit what can be shared. Read the chapter →

A passage worth sharing.

Select a passage in the chapter, or share the one you’re reading.