Open Weights vs Open Source: Which Robot Policies You Can Ship

The OpenVLA model card on Hugging Face says the weights are MIT: "All OpenVLA checkpoints, as well as our training codebase are released under an MIT License." The README in the OpenVLA repository, written by the same team, says the opposite: the pretrained models "are derived from Llama-2, and as such are subject to the Llama Community License." Both were live on 23 August 2026. Only one survives a legal review.

"Open weights" and "open source" are not the same thing. A vision-language-action model ships as three separable layers: training code, model parameters, and the data behind them. Each carries its own terms, and a badge only describes the first. Below: what each of the five policies you can fine-tune here is licensed under, the document that says so, and where two official documents disagree.

Open weights, open source, and the word the OSI actually defined

The Open Source Initiative's Open Source AI Definition 1.0 is the only widely cited attempt to pin the phrase down for a trained policy. It grants four freedoms (use, study, modify, share) and then lists what must be published for them to be exercisable. That list is where robot models fall over.

The licence of every policy you can train today

Every cell below was read from the live source on 23 August 2026.

GR00T: one repository, two opposite sentences

The GR00T N1.7 case shows why a single line is never enough. The Isaac-GR00T README contains both of these, about 530 lines apart.

# Isaac-GR00T README, line 70:
GR00T N1.7 is fully commercially licensable under Apache 2.0. It delivers
comparable performance to N1.6, with improved generalization ...

# Isaac-GR00T README, License section, line 599:
## License

- **Code:** Apache 2.0 - see [LICENSE](LICENSE)
- **Model weights:** [NVIDIA Open Model License](...)

The License section is correct, and the card agrees: "This model is released under the NVIDIA Open Model License Agreement", described as "ready for commercial/non-commercial use". So N1.7 is shippable. The line-70 phrasing is loose rather than malicious, but quote it in a compliance document and you have cited the wrong licence.

Distributing the model or a derivative requires the notice "Licensed by NVIDIA Corporation under the NVIDIA Open Model License". Because the backbone is Cosmos-Reason2-2B, the Cosmos clause adds "Built on NVIDIA Cosmos" in your documentation, website or interface. The licence terminates automatically on patent or copyright litigation, or on circumventing a safety guardrail. NVIDIA claims no ownership in outputs.

A smaller wrinkle on the same card: the line announcing the backbone reads "GR00T-N1.7 VLM backbone is now Cosmos-Reason2-2B" while the link under it points at Cosmos-Reason2-8B. Both pages resolve and carry the same licence, which is why nobody has noticed.

Pi0.5: an Apache-2.0 repository with a second licence file in it

The Pi0.5 code lives in Physical Intelligence's openpi repository. GitHub reports it as Apache-2.0, which is right for the code. The repository root holds two licence files.

$ ls   # openpi repository root
CONTRIBUTING.md
LICENSE              <- Apache License 2.0
LICENSE_GEMMA.txt    <- "Gemma Terms of Use, Last modified: February 21, 2024"
README.md
docs/  examples/  packages/  scripts/  src/  third_party/

The reason is architectural: Pi0.5 is a flow matching policy on a PaliGemma backbone, and PaliGemma ships under the Gemma Terms of Use, not an OSI licence. That propagates to the LeRobot mirror of the base checkpoint, which is the artifact this platform fine-tunes. Its frontmatter says so in one line.

---
language:
- en
library_name: lerobot
pipeline_tag: robotics
tags:
- vision-language-action
- imitation-learning
- lerobot
inference: false
license: gemma
---

• A fine-tuned Pi0.5 checkpoint is a "Model Derivative", defined as any modification to Gemma or work based on it.
• "Distribution" explicitly includes "providing or making Gemma or its functionality available as a hosted service via API, web access, or any other electronic or remote means". Serving your policy from a cloud endpoint is Distribution.
• On distribution you must pass the Section 3.2 use restrictions through in your own enforceable terms, give recipients a copy of the agreement, and mark modified files. The Notice file reading "Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms" is required for every Distribution other than through a Hosted Service, so the API case skips that one duty.
• Google reserves the right to restrict usage, remotely or otherwise, of anything it reasonably believes breaches the agreement.
• Outputs are not Model Derivatives and Google claims no rights in them. The joint angles your policy emits are yours.

SmolVLA: the licence field is empty

The SmolVLA code is unambiguous: lerobot is Apache-2.0 and the SmolVLM-2 backbone checkpoints are Apache-2.0. The weights are the problem, because there is nothing there to read. The lerobot/smolvla_base frontmatter ends at inference: false with no license key, the Hub API returns none, and the SmolVLA paper does not contain the string "license" once in 24 pages.

# check any Hugging Face repo's declared licence without cloning it
curl -s https://huggingface.co/api/models/lerobot/smolvla_base \
  | python3 -c "import sys,json; c=json.load(sys.stdin).get('cardData',{}); \
      print('license:', c.get('license'), '| name:', c.get('license_name'))"
# license: None | name: None

curl -s https://huggingface.co/api/models/lerobot/pi05_base \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['cardData'].get('license'))"
# gemma

This is not bad faith. By the OSAID standard SmolVLA is the most open model here, because the team published the data too: pretraining used a filtered subset of 481 community datasets from the Hub, 22.9K episodes and 10.6M frames. GR00T and Pi0.5 publish nothing comparable. But undeclared is undeclared, and those 481 LeRobot datasets came from hobbyists whose licence fields drift as described below. If you need a written permission for a reviewer, open an issue on the lerobot repository.

ACT: clean, with one ImageNet-shaped asterisk

The ACT case is easy structurally: there is no ACT base model. It trains from scratch on your task, so no vendor checkpoint enters your build. The original ALOHA repository is MIT, copyright 2023 Tony Z. Zhao; the LeRobot port carries an Apache-2.0 header crediting Zhao and Hugging Face; the action chunking model definitions are adapted from DETR, which is Apache-2.0. Every layer is OSI-approved. The asterisk is in the default config.

# lerobot/src/lerobot/policies/act/configuration_act.py
chunk_size: int = 100
n_action_steps: int = 100
vision_backbone: str = "resnet18"
pretrained_backbone_weights: str | None = "ResNet18_Weights.IMAGENET1K_V1"

OpenVLA and Octo: two MITs that mean different things

Back to the opening. The OpenVLA card declares license: mit in frontmatter, states "License: MIT" in the model summary, and asserts MIT for all checkpoints. The repository README, under "Explicit Notes on Model Licensing & Commercial Use", says the pretrained models inherit restrictions from Llama-2 and fall under the Llama Community License. The upstream Prismatic authors say the same about their own weights.

That difference is not academic. The Llama Community License adds a notice requirement, an acceptable use policy, a bar on improving competing language models, and a separate-licence trigger above 700 million monthly active users. MIT adds none of those. Because Hugging Face indexes the frontmatter, filtering the Hub by MIT returns openvla-7b, so the less careful document is the one everyone sees. Octo is the counterexample: MIT repo, MIT card, a T5-Base language encoder rather than a restrictively licensed LLM, 93 M parameters. Small models on permissive backbones do not accumulate licence debt.

The data layer, where the drift is worst

Dataset licences degrade every time somebody re-uploads a dataset in a new format. The clearest instance sits in NVIDIA's own N1.7 card, which names its SimplerEnv Bridge data as a LeRobot conversion of BridgeData V2.

Auditing a policy's licence in about five minutes

Short enough that skipping it is a choice, and it catches every contradiction above.

1. 1
   Read the weights frontmatter, not the rendered page

   An absent licence renders as no badge, not a warning. Query the API so it shows as None.

   bash

   for m in nvidia/GR00T-N1.7-3B nvidia/GR00T-N1.5-3B lerobot/pi05_base lerobot/smolvla_base; do
     echo -n "$m -> "
     curl -s "https://huggingface.co/api/models/$m" \
       | python3 -c "import sys,json; c=json.load(sys.stdin).get('cardData',{}); print(c.get('license'), c.get('license_name'))"
   done

2. 2
   Look for a second licence file in the repository

   GitHub's detector reports one LICENSE. A second file means the project knows the code and the weights differ.

   bash

   git clone --depth 1 https://github.com/Physical-Intelligence/openpi
   ls openpi | grep -i licen
   
   # LICENSE
   # LICENSE_GEMMA.txt

3. 3
   Grep the README and read every hit

   Do not skim. The contradictions live between the first hit and the last.

   bash

   curl -s https://raw.githubusercontent.com/NVIDIA/Isaac-GR00T/main/README.md \
     | grep -n -i "licen\|commercial"
   
   # 70: ... fully commercially licensable under Apache 2.0 ...
   # 601: - **Code:** Apache 2.0
   # 602: - **Model weights:** NVIDIA Open Model License

4. 4
   Walk up the backbone chain until the terms have no parent

   GR00T N1.7 leads to Cosmos-Reason2-2B, Pi0.5 to PaliGemma, OpenVLA to Prismatic and then Llama-2. Note gating: a gated backbone is an account dependency.

   bash

   curl -s https://huggingface.co/api/models/nvidia/Cosmos-Reason2-2B \
     | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['cardData'].get('license_name'), '| gated:', d.get('gated'))"
   
   # nvidia-open-model-license | gated: auto

5. 5
   Archive what you read, with the date

   Upstream edits model cards without a history a reviewer can follow. The copy you can produce in six months is the only one that counts.

   bash

   d=$(date +%F); mkdir -p licence-audit/$d
   curl -sL https://huggingface.co/nvidia/GR00T-N1.7-3B/raw/main/README.md \
     -o licence-audit/$d/groot-n17-card.md
   curl -sL https://raw.githubusercontent.com/Physical-Intelligence/openpi/main/LICENSE_GEMMA.txt \
     -o licence-audit/$d/openpi-gemma-terms.txt

Doing it yourself versus doing it here

# GR00T N1.7: weights under NVIDIA Open Model License, commercial use permitted
CUDA_VISIBLE_DEVICES=0 uv run python \
    gr00t/experiment/launch_finetune.py \
    --base-model-path nvidia/GR00T-N1.7-3B \
    --dataset-path demo_data/cube_to_bowl_5 \
    --embodiment-tag NEW_EMBODIMENT \
    --modality-config-path examples/SO100/so100_config.py \
    --num-gpus 1 \
    --output-dir /tmp/test_finetune \
    --max-steps 2000 \
    --global-batch-size 32 \
    --dataloader-num-workers 4

# change 1.7 to 1.5 above and your output checkpoint is non-commercial.
# Nothing in the CLI output will say so.

# Pi0.5 via openpi: Apache-2.0 code, Gemma-licensed weights
uv run scripts/compute_norm_stats.py --config-name pi05_libero
XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_libero \
    --exp-name=my_experiment --overwrite

# SmolVLA via lerobot: Apache-2.0 code, undeclared weights licence
lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=${HF_USER}/mydataset \
  --batch_size=64 --steps=20000 \
  --output_dir=outputs/train/my_smolvla \
  --policy.device=cuda

Whether restrictive weights are worth it

What this platform does not solve

AY-Robots rents GPUs, runs vendor trainers on your LeRobot dataset and serves the result. It does not grant you a licence, indemnify you, audit the dataset you supplied, or warn you when the model you picked is non-commercial. Your checkpoint carries whatever terms the vendor's base checkpoint carried.

A second limit shapes what you can ship at all: inference has to sit next to the servos for fast tasks. The control loop runs at 20 to 485 ms per action step depending on model, and public-internet round trips turn a working policy into a hesitant one. The inference pod auto-provisions a GPU and kills itself on an idle watchdog so nothing bills silently, but no watchdog fixes the speed of light. Cloud inference suits slow pick-and-place, not fast reactive motion.

It helps indirectly: every benchmark number in the arena links to the paper or model card it came from, the same document that carries the licence.

A default that survives a legal review

One recommendation instead of a matrix: for a commercial SO-100 product, fine-tune GR00T N1.7, archive the NVIDIA Open Model License text with the date you fetched it, and put the required notice plus "Built on NVIDIA Cosmos" in your documentation. For research, anything here works including GR00T N1.5. For a product with no upstream weight terms at all, train ACT on your own imitation learning data with the ImageNet backbone disabled, and pay for that cleanliness in episodes.

One last licence-adjacent trap: a LeRobot v3.0 dataset crashes the GR00T loader and must be converted down to v2.1, and conversion is exactly where a licence field gets rewritten by whoever ran the script. See the dataset version failure mode, and the first-policy walkthrough. Further reading: how VLA models work, the flow matching lineage behind Pi0.5, and Open X-Embodiment, whose per-dataset terms sit under most of these models.