Having the parameters is not the same as having the code, and it is not the same as calling an API. What open-weight models are, what the license actually requires, and how an enterprise decides whether to run them.
An open-weight model lets you download and run the parameters on infrastructure you control. That does not make it open-source software, and it is not an automatic substitute for a closed API. The decision is one of architecture and governance: data sovereignty, cost, latency, and fine-tuning, set against operations, security, evaluation, and compliance with that version’s license.
What an open-weight model is (and what it is not)
An open-weight model publishes its parameters: they can be downloaded and run in an environment the enterprise controls, or handed to a provider to be served as a managed service. That changes the data perimeter and the control you have over the version. It is not enough to call the model open source.
| Category | What you get | What you do not get |
|---|---|---|
| Closed API | An endpoint and a usage contract | The weights, the serving stack and, usually, fine-grained control of the version |
| Open weights | The parameters and, in most cases, inference code | Not necessarily the data or the training code, and not necessarily a permissive license |
| Open source (the OSI definition) | Freedoms to use, modify, and redistribute without discriminating against users or fields of use | — |
A model can be excellent, downloadable, and useful, and still not be open source if the license restricts a class of users or a field of use. The mistake is not using it: it is mislabeling it and discovering the condition once the use case is already in production. There is also no need to force a false choice: open weights can run on your own cluster, in a private cloud, or as a managed service on Azure, AWS, or another provider. Having them available does not require standing up a GPU team on day one.
The license belongs to the version, not the brand
No table replaces reading the license text for the version you are going to download.
| Family | Typical license (always verify the version) | What to check before you approve |
|---|---|---|
| Llama (Meta) | Llama 4 Community License: commercial use with conditions; not open source | A 700-million monthly active user threshold as of the release date; a “Built with Llama” notice; naming of derivatives; an acceptable use policy that includes a ban on circumventing safety measures |
| Mistral | Several families under Apache 2.0; some versions have used a research license or commercial conditions | The card for that version, not the brand name |
| Qwen (Alibaba) | Several versions under Apache 2.0; others carry a community license or additional conditions that depend on size | Conditions if the model is offered as a service, and any threshold that applies to the variant |
| DeepSeek | Several versions published under the MIT license | Keep the notice; a distillation may inherit the license of the base model |
| Gemma (Google) | Gemma 4 under Apache 2.0. Gemma 1 through 3 remain under the Gemma Terms of Use | Do not assume “Gemma” is a single license |
| gpt-oss (OpenAI) | Apache 2.0 | The usage policy published alongside the weights |
The license lives in the repository for that version, not on a slide. An acceptable use policy is part of the contract even when the file is titled “License.” In Llama 4, that policy prohibits circumventing or removing safety measures — a critical point when abliterated derivatives appear. Some licenses also include territorial or multimodal-use clauses: legal should read them before architecture picks a checkpoint.
When it makes sense to run them
- Data sovereignty. If the use case touches information that cannot leave the perimeter — personnel files, credit folders, contracts, data with a residency obligation — inference inside a VPC, a datacenter, or an isolated environment becomes a requirement. An API can be acceptable with a contract and controls; it is not acceptable when policy or a regulator requires that the data not travel.
- Cost at a given volume. The cost of an API is not the list price: it is the result of how the system is built. At high, predictable volume, a model you operate can lower the cost per outcome. At low volume, or with idle GPUs and a team that does not yet run inference, total cost usually loses to the API. Without a baseline cost per request, the comparison is an opinion in spreadsheet form.
- Latency. An assistant that queries internal systems, or a classifier in a transactional flow, benefits from inferring close to the workload. Latency is designed; it does not improve on its own.
- Fine-tuning and version control. Having the weights lets you adapt the model to a domain or an internal corpus, pin the version, and rehearse a rollback. That control is one of the strongest reasons to choose them, and it does not replace evaluations or governance.
What you take on: operations, security, evaluation, and governance
Running the model is the start of the work, not the end of it.
Operations. You have to serve it, scale it, observe it, and update it: compute, serving, reproducible deployments, and version rollback, with the same DevOps and testing discipline you would apply to any critical system. If it is hosted in the cloud, environment management comes with it. 54-4 implements on the client’s infrastructure and has a disclosed resale agreement with Microsoft and AWS: the business is the outcome, not the model license.
Security. A weight file is a supply-chain artifact, comparable to a binary. It is downloaded from a verified origin, its hash is checked, and who can register it in the internal catalog is restricted. Prompt injection, exfiltration through tools, and unintended data access do not disappear because the model is “ours.” A well-defined inference perimeter is part of the design.
Evaluations and roles. Once quality is no longer delegated to the API vendor, the enterprise measures task performance, hallucination, bias, and regression between versions, with an exit threshold for the pilot. A model in production needs an identity, a scope, a human owner, and a lifecycle — the same standard used to govern AI programmes.
| Role | Decides |
|---|---|
| Business owner of the use case | Whether the problem is worth solving, and what counts as an acceptable result |
| Architecture / AI lead | The pattern (API, managed service, or self-hosted inference) and the candidate version |
| Security (CISO or equivalent) | The perimeter, the provenance of the weights, and the connected tools |
| Legal and compliance | That version’s license, the data, and any sector obligations |
| Finance | Total cost versus the API, with explicit assumptions |
| Owner of the model in production | Operations, evaluations, version changes, and retirement |
If a role has no name attached to it, the decision has not been made.
Applicability in the enterprise: when to, and when not to
The useful question is not “should we move to open weights?” It is “for which use case, with which data, and with whom operating it?”
It makes sense, for example, when an assistant works over confidential internal documentation; a classification or summarization flow has high, stable volume and predictable compute utilization; inference has to live next to an operational system and meet a latency budget; you need fine-tuning on a proprietary corpus; the environment is isolated or there is a residency obligation; or you want to pin the version and roll back without depending on a vendor’s calendar.
It does not make sense, or not yet, when usage is sporadic and no one is there to operate GPUs, evaluations, or patches; the use case needs a capability that only a closed model covers honestly today, and the data classification allows an API under contract; the candidate version’s license conflicts with the intended use; or the only argument is that “open sounds better.” Starting with an API or a managed service is not a defeat: it is proportionality.
Who decides. The business owner proposes the use case. Architecture or the AI lead chooses the pattern and the version. Security and legal can veto on provenance, perimeter, or license. Finance validates total cost. An AI governance or model-risk committee, when one exists, approves entry into production. The model owner is named before the pilot, not after an incident. A proof of concept with a bounded use case, an exit criterion, and a record of the version is the most honest path.
How to decide, in practice
- Name the use case, the data, and its classification. If you cannot say what information enters the prompt, you cannot choose the perimeter.
- Read the license and the acceptable use policy for the specific version, with legal.
- Compare total cost — infrastructure, people, evaluations — against an API, with a baseline cost per request.
- Define evaluations and the pilot’s exit threshold before writing a line of serving code.
- Decide the deployment mode: self-hosted inference, a managed service, or a hybrid by use case.
- Assign the roles in the table above and the version rollback plan.
- Only then, scale.
Frequently asked questions
What is an open-weight model?
It is a model whose parameters can be downloaded and run on infrastructure you own or on a cloud environment you control. Having the weights does not mean you have the training code, the data, or an open-source license. It also does not require you to operate the model yourself: it can be consumed as a managed service.
Is open-weight the same as open source?
No. Open source, in the Open Source Initiative sense, requires freedoms to use, modify, and redistribute without discriminating against users or fields of use. Many model licenses — the Llama Community License is the most cited example — allow commercial use with conditions and do not meet that definition.
When does it make sense to run an open-weight model in the enterprise?
When a use case has the volume or sensitivity to justify operating it: data that must not leave the perimeter, latency next to internal systems, fine-tuning on proprietary information, or control over the version. If usage is occasional, there is no capacity to operate or evaluate, or the license does not fit, a closed API is usually the more honest option.
Can you fine-tune an open-weight model on internal data?
Yes, and it is one of the reasons to choose them, provided that version’s license allows it and the data is classified and controlled. Fine-tuning does not remove the need for evaluations, a named model owner, or a version rollback plan.
Who should approve the use of an open-weight model?
The business owner of the use case, architecture or the AI lead, security, legal, and finance, with a named owner of the model in production. In regulated environments, a model-risk committee or function is also in the room. No one approves a weight file alone.
Next step
If you are evaluating a concrete use case, the next step is an applicability assessment: the data and its classification, the candidate version’s license, total cost versus an API, and whether a managed service or self-hosted inference is the better fit. From there, when it is warranted, we run a pilot with evaluations and an exit criterion, then implement and operate the model in production under a governance model.
54-4 is a services firm, not a model vendor: turnkey projects and dedicated delivery pods. We implement on the client’s infrastructure and resell Microsoft and AWS under a disclosed arrangement; what you contract is the work, not a weight license. If you want to review a use case, get in touch.
Let's talk about your next platform
54-4 builds and modernizes business-critical software with senior teams across the Americas.
Schedule a consultation