Skip to main content

Open and closed models

A model you call over an API and a model you download are the same kind of object underneath. The difference is whether anybody will give you the file.

The file​

are that file. Numbers, billions of them, arranged in the shape the architecture expects, every one set by a training run that finished months ago. They are the whole learned content of the model. What it knows about French grammar is in there. So is its habit of formatting lists a particular way, and its refusal to explain how to make a nerve agent.

On their own the numbers do nothing. You need code that knows how to multiply an input against them. That code is small, well understood, and mostly free: a competent engineer can get a downloaded model answering questions in an afternoon. The weights are the part that took the money. Buying the GPUs and running them for the months a training run takes is the most expensive thing anybody in this industry does. The file is what comes out of it. So when a publisher decides whether to release weights, it is deciding whether to give away the asset.

Model sizes are quoted in parameters, one parameter being one number in the file. A model described as 70B has roughly seventy billion of them. That figure is the first thing you need if you ever intend to run it yourself, for reasons the local inference page goes into.

A line, not a switch​

People ask whether a model is open or closed as though there were two bins. There are positions along a line, and the useful ones are these.

At one end, a model that exists only as a hosted API. There are no weights to download and no way to run it on a machine you control. You send text to an endpoint and text comes back. That is a . The vendor holds the file and never lets go of it, which also means the vendor can change what the file is while the name you call stays the same, or retire the name entirely on whatever notice its deprecation policy promises.

In the middle, and this is where most of the interesting models sit, the weights are published for anyone to download, under a licence written by the publisher for this purpose. That is an . The file is yours. What you may do with it is whatever the document says, and the document is not one of the licences you already know.

At the far end, a release where the weights, the training code, and a real description of the training data all come out together under a licence an open source body would recognise. This is rare. Publishers release weights under a permissive licence reasonably often now. Releasing the pipeline that produced them is a different decision and almost nobody makes it.

Where each freedom starts along the openness line A horizontal axis with four marked positions, from left to right: hosted API only; weights published under a bespoke licence; weights published under Apache-2.0 or MIT; weights plus training code plus a training data description under an approved licence. Beneath the axis are five capability rows. Downloading the weights, running the model with no vendor call, and fine-tuning it all begin at the second position. Using it commercially with no separate agreement and no use policy begins only at the third. Checking how the model was trained begins only at the fourth. Each row is drawn as a thin dashed line marked "no" up to the point where the capability starts, then a thick solid line marked "yes" to the right of it, with a dot at the point where it switches. The rows switch on at different places, so the capabilities do not arrive together. Openness is a position, not a box More open to the right. Each row below turns on where its dot sits. Hosted API onlyno weights, nodownload Weights published,bespoke licenceby the publisher Weights published,Apache-2.0or MIT Weights, code anddata description,approved licence closed open source Download the weights no yes from here Run it with no vendor call no yes from here Fine-tune it on your own data no yes from here Use it commercially with noseparate agreement or use policy no: threshold, credit and use policy still apply yes from here Check how it was trained no: the corpus is described, not shipped yes, only here Three of the five rows turn on at the bespoke licence. Two do not, and those two are the ones a lawyer asks about.
The freedoms you want do not all arrive at the same place on the line, so 'open' on its own tells you nothing about which ones you have.

Why open weights is not open source​

Software is open source when the source that produced the running artefact is available under an approved licence, and anybody may use it for any purpose, including purposes the author would hate. Both halves are load-bearing. A model release usually fails both.

Take the source half first. For a program, the source is the code a compiler turned into the binary. For a model, the thing that corresponds to source is the training data and the training code, because those are what produced the weights. Almost no publisher releases either. What you get instead is a model card with a paragraph describing the corpus in general terms, a cutoff date, and some benchmark scores. That is a description of the data. It is not the data, and you cannot re-derive the weights from it.

So the weights are closer to a compiled binary than to source. You can run them. You can modify them by , which means continuing to train the published model on your own examples until it behaves the way you want. That does change the numbers in the file. It still tells you nothing about what any of those numbers meant beforehand, or which documents put them there, or whether something you would rather not ship was in the corpus. A binary you can patch is still not source.

Now the licence half. The attached to a weight release is often bespoke, written by the publisher's lawyers, and named after the model. Read one and you will find terms an approved open source licence is not permitted to contain:

  • An , incorporated by reference, listing things you may not do with the model. Open source licences do not restrict fields of endeavour. This is the clause that most clearly puts a licence outside the definition.
  • An obligation to display a credit. Some licences require the publisher's name shown on your product's documentation or interface, and require any model you fine-tune to carry the original model's name at the front of its own.
  • A threshold. Above some number of monthly active users on the release date, you stop being covered and have to go and ask for a commercial licence. Small companies never hit it. It exists to stop the publisher's largest competitors using the release for free, and it is a real term in real licences that get called open source in public.

None of that makes the licence bad. It makes the licence something other than open source, which is a different complaint. So read the licence for the specific model and the specific version you intend to ship, rather than the summary on the download page or a blog post about it. When a vendor's marketing says "open source model", the safe reading is "the weights are downloadable", and everything past that needs checking.

Check the model licence before it ships

Open the licence file for the exact model and version you will ship.

  1. Read the licence text. Do not rely on the download page.
  2. Record the licence name and the model version it covers.
  3. Read the acceptable use policy. The licence incorporates it by reference.
  4. Find any user threshold that requires a separate commercial licence.
  5. Find any credit you must display on your product or in your model name.
  6. Confirm whether you may redistribute the weights and any fine-tuned model.
  7. Send the licence to legal counsel before the model reaches production.

What each end buys you​

What open weights buy is specific, and none of the five things on the list is "it is free".

You can run it where you like: on a laptop, in your own data centre, inside a cloud account under your own controls, or on an air-gapped machine with no route out. A version you have downloaded keeps working after the publisher has moved on to the next one, because nobody can take a file off your disk. You can fine-tune it on data you would never send to a vendor. Interpretability and safety teams can watch what happens inside it layer by layer, which matters to them and to almost nobody else. And you pay for hardware and electricity rather than for tokens, which changes the shape of the bill even when it does not change the size.

Closed models buy you a different set. The best model available at any moment is usually a closed one, and the gap at the top has been persistent even while open releases have got much better. You buy no hardware and hire nobody to keep it running. Somebody else handles abuse, jailbreaks, safety classifiers, and the queue of things that go wrong at three in the morning. Capacity is somebody else's problem. For most teams that adds up to far more capability per unit of engineering effort, so most products are built this way.

Lock-in, in both directions​

The argument for open weights is usually made as an argument about lock-in, and it is half right.

A closed model locks you in through the API and through the behaviour. Swapping vendors means new SDK calls, which an LLM gateway can hide, and it means every prompt you tuned now behaves slightly differently, which nothing can hide. You are also exposed to the vendor's schedule. If the model you built on is retired, you migrate whether you had budget for it or not.

Open weights remove that particular exposure and add another. The eight GPUs you bought to serve a 70B model are a capital asset with one use. If the next model you want is twice the size, or uses an architecture your serving stack does not support, the hardware does not follow you. Teams describe this as freedom and then find they have picked their model to fit the cards. The lock-in moved from a contract to a loading bay.

Most organisations end up holding both, and the split is usually about the data rather than about the cost. That is the local and cloud question.

Terms introduced​

  • Weights: the file of numbers a training run produced, holding everything the model learned.
  • Open-weights model: a model whose weights are published for download, under whatever licence the publisher chose.
  • Closed model: a model reachable only as a hosted service, whose weights are never released.
  • Model licence: the terms attached to a weight release, often bespoke and often not open source.
  • Acceptable use policy: a list of prohibited uses, incorporated into a model licence by reference.
  • Fine-tuning: continuing to train a published model on your own examples so that it behaves differently.

How providers do it

Two of these four publish weights, and only one of the two publishes them under a licence an open source body would recognise.

ProviderWeights published?Licence familyExtra conditions in the licence
AnthropicNoNone. Hosted service onlyNot applicable
OpenAIYes, gpt-oss-120b and gpt-oss-20bApache-2.0None in the licence. A separate usage policy applies
GoogleYes, GemmaApache-2.0 on Gemma 4; bespoke Gemma Terms of Use before itProhibited Use Policy and notice requirements on the bespoke terms
MetaYes, LlamaBespoke Llama 4 Community LicenseAcceptable Use Policy, "Built with Llama" credit, "Llama" name prefix, 700M MAU threshold

Every row above is confirmed against the licence text or model card named in that provider's tab. Still open: whether Anthropic offers any managed customisation on a partner cloud, the text of OpenAI's gpt-oss usage policy, and what the Llama 4 model card says about the corpus.

The Meta row is the one to remember. Llama is the model most often called open source in public, and its licence contains a field-of-use restriction, a naming obligation and a user threshold, none of which an approved open source licence may contain. Meanwhile gpt-oss ships under a textbook open source licence and still is not an open source model, because the training data and the training code were not released either. The licence and the openness of the model are two separate questions and you have to ask both.

What this maps to: Anthropic sits at the closed end of the line. Claude is sold as a hosted service on the Claude API and on three other companies' clouds, and no Claude weights are published anywhere.

QuestionAnswerStatus
Are weights published for any model?No. Every Claude model listed on the models overview is reachable only through an API: the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry, or Claude Platform on AWSconfirmed
What licence family covers the models?Not applicable. There is no weight licence because there is no weight release. Use is governed by commercial terms and usage policies rather than by a model licenceconfirmed
Acceptable use terms?Yes, as a usage policy on the service. It is not incorporated into a weight licence, because none existsunconfirmed; the usage policy text itself was not read today
Can a published model be fine-tuned and redistributed?No published model exists to fine-tune. Whether any managed customisation is offered on a partner cloud was not checkedunconfirmed; open question is whether Bedrock or Vertex expose a Claude customisation path today
Is the training data described?The models overview publishes a training data cutoff per model and points at Anthropic's Transparency Hub for the rest. The corpus itself is not described in detail thereunconfirmed; the Transparency Hub was not read today

Their vocabulary

Standard termTheir term
Closed modelNo term of its own. Models are listed by name with a platform each is available on
Model retirementDeprecation, with a published "not sooner than" retirement date per model
Version pinningModel ID, which is a pinned snapshot, plus an alias for some generations

Where to look

The models overview page carries a row per model for context window, pricing, training data cutoff, and the retirement commitment. That retirement row is the one to read if you are weighing a closed model against a downloadable one, because it is the closest thing to a guarantee that the model you build on will still be there.

Last verified: 2026-09-09 against https://platform.claude.com/docs/en/about-claude/models/overview.

Check your understanding

0 of 4 answered

  1. A vendor's download page calls its model "open source". The licence is named after the model, incorporates an acceptable use policy, and requires a separate agreement above 700 million monthly active users. Is the model open source?
  2. A publisher releases the weights for a model on a download site. What has it released?
  3. A team builds a product on a closed model reached only through the vendor's API. What risk does that carry which an open-weights model does not?
  4. You are about to ship a fine-tuned version of a published model in a customer-facing product. Which obligation is most likely to be sitting in the licence and missed?