solution-licensing

Files (1)

• SKILL.md

SKILL.md (first lines)

# Solution Licensing And Redistribution

Use this skill whenever work adds something new to what NPA ships: a workbench
tool, a BYOF/OSS solution, a container image, a base-image swap, a model, or a
dataset. It answers one question:

> We are about to bundle someone else's software. **Who may we hand the result
> to, and in what form?**

"It's open source" does not answer that. The whole point of this skill is that
the answer usually depends on components the top-level license does not cover.

This is engineering guidance for classifying and recording a decision, not legal
advice. When a license is novel, ambiguous, or the vendor's own sources
disagree, record the finding and escalate to a human rather than picking the
convenient reading.

## When To Use

- Onboarding an OSS or partner solution (pairs with
  `skills/workflows/oss-solution-registry-onboard/SKILL.md`, whose License
  admission gate this skill implements)
- Adding a workbench image or changing a Dockerfile's `FROM`
- Adding a model, checkpoint, or dataset to a workflow
- Deciding whether something may be published to a public registry
- Reviewing a PR that does any of the above

Before any provisioning, build, download, or submission that depends on a
third-party EULA, also load
`skills/atomic/third-party-eula-preflight/SKILL.md`; licensing classification
does not itself establish operator consent or upstream asset access.

When the classification says an artifact may be used but not baked or
redistributed, load `skills/workflows/runtime-fetch-onboard/SKILL.md`. It turns
that decision into a bootstrap-container, runtime-delivery, cache, and validation
contract so a restricted weight or SDK does not unnecessarily block the rest of
the onboarding.

## The Six Artifact Boundaries

Classify each boundary separately. A permissive answer at one boundary says
nothing about the others.

| Boundary | What it is | Typical trap |
| --- | --- | --- |
| **Source** | The project's own code | Apache/MIT badge on a repo whose *build* pulls proprietary parts |
| **Baked runtime** | Everything the image carries: base image, wheels, SDKs, binaries, assets, fonts, textures | Free to *use*, not to *redistribute* |
| **Weights** | Model checkpoints, adapters, tokenizers, and auxiliary model files | Treating registry access control as permission to redistribute baked bytes |
| **Datasets** | Training, evaluation, calibration, and example data | Assuming a model license also covers its data |
| **Runtime caches** | Downloaded weights, SDKs, compiled kernels, and mutable runtime state | Assuming runtime fetch is durable, or persisting credentials beside cached bytes |
| **Outputs** | What the model generates when an operator runs it | Terms that restrict what the *generated artifacts* may be used for, and that therefore bind pipeline stages downstream of the model |

The decisive layer is normally the **baked runtime**, because publishing an image
distributes every byte in it to whoever pulls it.

**Outputs** is the boundary people forget, because it is the one that is not
about redistribution at all. Ship an image containing none of the vendor's bytes
and every other boundary goes quiet — while a term like "you may not use the
Outputs to train another model" stays fully in force and lands squarely on the
next stage of the workflow. See the LTX-2.5 precedent below.

## Procedure

### 1. Enumerate what the artifact actually ships

Do not read the README. Read the Dockerfile and the lockfile.

```bash
grep -nE '^(FROM|ARG .*(BASE|IMAGE|VERSION))' npa/docker/workbench/<tool>/Dockerfile
grep -nE 'pip install|apt-get install|curl|wget|COPY --from' npa/docker/workbench/<tool>/Dockerfile
```

List: base image, every SDK/wheel installed from a vendor index (for example
`pypi.nvidia.com`, `nvcr.io`), anything downloaded at build time, baked weights,
datasets, and every cache path populated or mounted at runtime.

### 2. Find each component's real license

Prefer the vendor's own licensing page or the package's own metadata over a
repo badge or a summary. Useful checks:

```bash
pip download --no-deps --no-binary :all: <pkg>   # then read the sdist metadata
npa/.venv/bin/python -c "import importlib.metadata as m; print(m.metadata('<pkg>')['License'])"
```

A package whose `License` field literally reads *"NVIDIA Proprietary Software"*
settles the question regardless of what the GitHub repo's badge says.

For compiled wheels, inspect embedded dependencies, certificate data and fonts,
not only the package's top-level grant. An SBOM license expression does not
deliver required copyright or permission text. Bind the exact notices and any
required corresponding source to the shipped artifact/member hashes, then
verify that recipients actually receive those bytes, including obligations for
superseded components retained in ancestor layers.

### 3. Ask the redistribution question explicitly

For every component, answer these four separately — permission for one is not
permission for another:

1. May we **use** it internally?
2. May we **redistribute** it to third parties (shipping an image counts)?
3. May we **run it as a service** for third parties? Vendors often treat
   "install and operate it for a customer" as redistribution even though no
   bits change hands.
4. Are there **field-of-use limits** (non-commercial, research-only, no
   competing service, evaluation-only)?
5. What may the operator do with the **Outputs**? Restrictions here survive
   every packaging trick, because they attach to artifacts we never touch.
6. Do any obligations depend on **facts about the operator** — revenue,
   headcount, entity type, whether this particular use is commercial? If so,
   nobody upstream of the operator can answer them, which changes what the
   image must ask for at run time (see below).

### 4. Resolve conflicting vendor sources

Vendors publish general terms and product-specific terms, and they diverge.
When they do, prefer the source that is **more specific to the component we

From nebius/nebius-physical-ai, Apache-2.0.

More from nebius/nebius-physical-ai