The GR00T license and commercial use, answered from the file

No. The license file that ships with the GR00T N1.7 weights does not permit commercial use. It limits the model to research and evaluation, keeps commercial rights with NVIDIA and its affiliates, and pushes that limit into every fine-tune. Three other NVIDIA surfaces tell a different story. The model card, the code repository, and the launch post all point to a license that would allow commercial use. This guide quotes the file, sets the four claims side by side, explains which document governs your copy, and names two Apache-2.0 vision language action models you can run commercially instead.

The answer decides what you may ship. A robot built on blocked weights is a robot you cannot sell. The rest of this page shows the text, the conflict, and the way out.

What the distributed LICENSE file says

The weights repository at nvidia/GR00T-N1.7-3B on Hugging Face ships a file named LICENSE. It is 4,063 bytes. Its title is "NVIDIA License". Not "NVIDIA Open Model License". Section 3.3 is the clause that answers the commercial question. Here is its full text, fetched from the LICENSE file on October 5, 2026:

3.3 Use Limitation. The Work and any derivative works thereof only may be used or intended for use non-commercially. Notwithstanding the foregoing, NVIDIA Corporation and its affiliates may use the Work and any derivative works commercially. As used herein, "non-commercially" means for research or evaluation purposes only.

Three sentences, three rules.

Rule one: the weights may be used non-commercially only. The file defines that term narrowly: research or evaluation purposes, nothing wider.

Rule two: NVIDIA Corporation and its affiliates may use the same weights commercially. That right stays with NVIDIA. It does not pass to you on download.

Rule three: derivative works carry the same limit. Section 3.2 closes the loop. You may attach your own terms to your fine-tune only if your terms keep the section 3.3 use limit. A fine-tune of GR00T stays non-commercial. Section 3.1 adds that redistribution must ship under this license itself. You cannot pass the weights on under friendlier terms.

Four claims, one model: which document governs

The confusion is not in your head: the official surfaces disagree.

The NVIDIA Open Model License is real, and it does allow commercial use. Its published text says models under it are commercially usable and that you may distribute derivative models. If the README were accurate, this page's answer would be yes.

The distributed file is not that agreement.

Which document governs? The license text that ships with the copy you downloaded. That is how weight licensing works: the file travels with every download, and section 3.1 forbids redistribution under other terms. When a repository's README and its LICENSE file disagree, the file is the document a careful reader reads first. NVIDIA has not updated the file. Three open discussions on the repository ask exactly this question, opened between April and August 2026. None has a reply from NVIDIA as of this page's verification date.

This page is engineering guidance, not legal advice. For a shipping product, read the file yourself and put the question to your lawyer.

Why everyone is confused: the GR00T family license map

Part of the muddle has a real source. The GR00T family is licensed piecewise, and the pieces follow different rules.

• The Isaac-GR00T code repository is Apache 2.0. Training code, inference code, and the fine-tuning workflow are genuinely permissive.
• GR00T-Dreams, the family's data generation model, also ships the Apache License 2.0.
• GR00T-WholeBodyControl, a sibling project from the same NVIDIA team, ships its weights under the Open Model License. Its license page says that license permits commercial use.
• The foundation weights are the exception. GR00T N1, N1.5, and N1.7 all ship the same non-commercial NVIDIA License file. The N1 file and the N1.7 file match word for word, apart from a trailing newline. The weights license has not changed since the first N1 release in March 2025.

So the claim "GR00T is Apache 2.0" was true of the code from day one. It was never true of these weights. The story spread from the code repository to social sites in March 2025 and stuck.

One more trap catches careful readers: the weights repository shows no license tag on its page. Tags are optional metadata the uploader fills in. The file is the source of truth. Read the file.

NVIDIA's own answer on the record

NVIDIA answered this question on its developer forum in July 2025, before N1.7 shipped. An engineer with an industrial fine-tuning project asked three direct questions about commercial use. NVIDIA staff replied on July 16, 2025 in the clarification thread:

Is it permitted to use the GR00T model weights for commercial applications (e.g., integrating into industrial systems)? Not in production - currently a research only license due to pre-training data license constraints.

If not, is there a process to request commercial licensing or permission from NVIDIA? Not currently. It's a data issue, not a license choice.

Are there any usage restrictions I should be aware of when deploying GR00T in a commercial product? Shouldn't deploy in a commercial product until we have a model that allows for commercial use.

Two points stand out. First, the limit is a data problem, not a formality NVIDIA can wave through. The pre-training data carries its own license constraints. Second, there was no permission process then, and the file has not changed since. The N1.7 launch post went up in April 2026 still calling the model commercially licensed. The file still says research only. If NVIDIA reconciles the file to match the marketing, this page changes with it. The verification date at the bottom is the freshness signal.

What you can still do with GR00T N1.7

The file permits research and evaluation. In practice that covers:

• studying the model, its architecture, and its behavior
• benchmark runs and comparisons against other models
• prototyping and internal experiments, including fine-tuning, while the goal stays evaluation
• papers, demos, and videos about your results

The line sits at deployment. A robot that serves a paying customer is not evaluation. An internal pilot that supports a live process sits in a gray zone, and the staff answer above says do not deploy in a commercial product. Note also what is genuinely open here. The Apache 2.0 license on the code repository is real. You may build products on the training and inference code with your own policy head, or with a different model's weights.

Commercially usable alternatives on the same hardware

If your robot needs to ship, two open model families do the same class of work under clear Apache 2.0 terms.

pi05, from the openpi project, is a flow-matching vision language action model. Its repository is Apache 2.0. It takes camera frames, an instruction, and the joint state, and returns an action chunk: the same request shape GR00T uses. The released base checkpoint carries 3,616,757,520 parameters, about 3.6 billion: a PaliGemma vision language backbone plus a 300 million parameter action expert. The base is trained on more than 10,000 hours of robot data, per the publisher's repository. Fine-tuned variants exist for standard arm embodiments, including a DROID tune the publisher's table calls its strongest generalist DROID policy. This platform carries a page per checkpoint: pi05-droid for the DROID tune, pi05-libero for the LIBERO tune.

On hardware, the publisher's table asks more than 8 GB of GPU memory for inference and names an RTX 4090 as the example card. LoRA fine-tuning wants more than 22.5 GB, and a full fine-tune more than 70 GB. The pi 0 paper measured 73 milliseconds per action chunk on an RTX 4090.

Run the file check on this family too, because its fine print has layers. The openpi repository license, read directly on October 5, 2026, is Apache 2.0. The LeRobot port card carries a Gemma license tag in its frontmatter instead. The PaliGemma tokenizer the model needs sits behind a license gate on the Hub, so you accept its terms and log in before a first run. None of this blocks commercial testing. It does mean a buyer reads the repo license and the port card before shipping a product on the weights. The port pages carry no license tag either, which is the same trap this page teaches you around.

MolmoAct2, from the Allen Institute for AI, is the second family. Its repository is Apache 2.0, verified by reading the license file, the same method this page teaches. The SO100_101 checkpoint family targets the same SO-100 and SO-101 class of arms as GR00T tutorials, and the ports ship the per-embodiment normalization statistics. It landed in May 2026 and passed 400,000 downloads inside three weeks. The tune rests on 38,059 episodes, 183.6 hours, from 1,222 public datasets by 377 contributors. On the SO-100 platform, the paper's own evaluation scored this tune 56.7 against 45.3 for a pi0 tune trained on the same data. Inference runs under 16 GB at bf16, about 12 GB in the LeRobot port, and LoRA fine-tuning fits on one 24 GB card. One note beside the file: Ai2 publishes responsible use guidelines naming research and educational use as the intended lane. Guidelines are guidance. The Apache 2.0 file governs your copy.

Both repositories are alive, not archived: the openpi repository counted about 14,000 stars and the MolmoAct2 repository about 800 on the October 5, 2026 read.

The split between them is embodiment. Run MolmoAct2 when your arm is an SO-100 or SO-101 and you want the tune that grew from thousands of community episodes recorded on exactly that arm. Run pi05 when your rig sits farther afield or language-following matters most, and tune from the base. Both speak the same request shape, so your client code does not care which one answers. And both ship their normalization statistics with the checkpoint, so the numbers that map actions onto your arm arrive with the weights.

Both are written up on this platform's action route, beyond the public list. The contract is one call per step: one to three camera images, an instruction, and the joint state go in. An action chunk comes back, with the normalization block for the embodiment. Neither lane is on the platform's list. The request shape looks like this:

curl -sS $IRONSTRATUM_BASE_URL/v1/action \
  -H "Authorization: Bearer $KEY" \
  -F model=pi05 \
  -F "instruction=stack the blocks" \
  -F "state=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0]" \
  -F image=@frame.jpg

Swap the model field to molmoact2-so100-101 for the other lane. Calls are metered per served request; the robot action rows are not on the public list, so no rate renders on the pricing page. Sign up and create a key now, and you are ready for the row the index lists: one frame in, one action chunk out. To run the model on your own hardware instead, this site carries a guide on the break-even math for local vision language action serving.

Check any model's real license in one minute

The method takes less than a minute. Open the LICENSE file in the repository itself. Not the tag. Not the README section.

curl -s https://huggingface.co/<org>/<model>/raw/main/LICENSE | head -40

Then search the text for the words "non-commercially", "research", or "use limitation". If the file names a different license than the README, the file wins for your copy. The check matters for the alternatives too. Their port pages also carry no license tag. The Apache 2.0 grant for each lives in its code repository: openpi for pi05, allenai for MolmoAct2.

Common questions

Is GR00T open source? The code is: the Isaac-GR00T repository carries Apache 2.0. The weights are not. Their license file restricts use to research and evaluation and reserves commercial use for NVIDIA and its affiliates.

Is GR00T N1.7 Apache 2.0? The weights are not. GitHub's Apache 2.0 label belongs to the Isaac-GR00T code repository. The weights repository ships the NVIDIA License file, and its section 3.3 is the non-commercial clause this page quotes.

Which license is correct, the README or the LICENSE file? For the copy you downloaded, the LICENSE file. It ships with the weights, and section 3.1 forbids redistribution under other terms. The README makes a claim the file does not back.

Can I fine-tune GR00T and sell the result? No. Section 3.2 requires the terms on your derivative work to carry the section 3.3 use limit. The restriction travels into the fine-tune.

Is there a way to buy commercial permission? No public process existed as of the July 2025 staff answer, and the file has not changed since. Watch the repository rather than assuming a path exists.

What is GR00T? Is it a VLA? GR00T is a vision language action model for robot manipulation. Images and instructions go in, robot actions come out. That class is why the alternatives above fit the same arms.

What can I use instead for a commercial robot? The two families above: pi05 and MolmoAct2. Same request shape, same arm class, clear Apache 2.0 grant.

Is NVIDIA Omniverse free to use? Separate product, separate terms. Omniverse is simulation software; the file this page reads does not cover it.

The short version

Read the file before you build. The file says research and evaluation only, and it has said so since March 2025. If your product needs commercial terms, take the open path: the Apache-2.0 alternatives above, and the action route when its lanes land. Rates will render on the pricing page that day. Sign up and create a key now, and you are ready: one frame in, one action chunk out.

Last verified: 2026-10-05