The LLM Freedom Manifesto: Open-Weight Models and User Responsibility


The LLM Freedom Manifesto: Power, Responsibility, and the Four Freedoms

The Conclusion of Our Reasoning

The LLM itself is not software—it is a statistical model, a file of weights and parameters. The software that runs it (inference engines) can and should be free software, but the model itself is a tool, not a program. The freedoms apply to the software, not to every piece of data used to train the model.

Training on copyrighted data is legal under current law and judicial precedent. The provider is not the only responsible party. The user who publishes output shares liability. You cannot outsource your responsibility to the tool’s creator. Even if an LLM were trained only on free texts, the user would still bear final responsibility for licensing compliance and attribution.

Creativity and responsibility are the keys. A transformative prompt, original context, and diligent editing make an output your own. You are the author, not the tool. We do not need “safe,” “sanitized,” or “public-domain-only” models. We need powerful, truthful, capable tools—and the maturity to use them wisely.

The freedom is already ours. Let’s use it well.

This is not recklessness. It is the conclusion of careful reasoning about the nature of Large Language Models, copyright law, and the ethical responsibilities of creators. After examining the legal landscape—including the GEMA ruling on song lyrics, the GitHub Copilot lawsuit, and the evolving case law around LLM training—we have arrived at a clear position:

The hunt for “fully free” LLMs is a fool’s errand. We are already free by law to have LLMs trained on any kind of text. The only question that remains is how we, as users, exercise that freedom responsibly.

Sharing LLM weights is fully in the spirit of the GNU Project. Users are free to download them, study them, modify them, and redistribute modified versions—just as the Four Freedoms require for software. The weights are a tool, not a substitute for human judgment. What matters is that the user has control over the tool and takes responsibility for how it is used, just as a programmer takes responsibility for code they adapt from a book or from someone else’s project. Using an LLM is no different in principle: you study, you adapt, you transform, and you own the result. The tool does not absolve you of responsibility; it empowers you to exercise it.

We simply have a new category of information: the LLM weight. It is not software, not a picture, not a text—it is a statistical artifact, a file of numbers that has no direct parallel in the traditional categories of copyright or free software. Upon the user’s prompt and inference, that artifact generates new output, but in itself it is just a static file. It is free to download, study, share, and modify—just as the GNU spirit encourages for any tool that empowers users. The final responsibility for copyright compliance and originality rests with the user, as it does when using a book, a compiler, or someone else’s code. The weight is a tool; the user is the author.

Why Training Data Is Not Source Code

Some in the free software community argue that training data is the “source code” of an LLM and that the weights are the “compiled” result. While this is a common analogy, it is not accurate.

Source code is human-readable instructions that programmers write and modify directly. It is the original form of a program, from which executable binaries are derived. Training data, by contrast, is a collection of text, code, or other content that a statistical model processes to learn patterns. The relationship between training data and weights is not the same as the relationship between source code and machine code.

A more accurate description is this: training data is material used to create a statistical artifact. The weights are not a “compilation” of the data in the sense that an executable is a compilation of source code. You cannot “decompile” the weights back to the original training data. The data is not preserved; it is transformed into a set of numerical parameters that encode statistical relationships.

This distinction matters for the Four Freedoms. The freedoms apply to software—to programs that users can run, study, modify, and share. They do not apply to every piece of data used to train a model, just as they do not apply to the books you read to learn a programming language. The tool is the inference engine and the surrounding software; the weights are a tool’s internal state.

The user, not the training data, bears responsibility for how the model is used. Whether the data is free or not, the user who generates and publishes output is the one who must ensure compliance with copyright and licensing terms.

The Four Freedoms and LLMs

Richard Stallman’s Four Freedoms define what it means for a program to be free software. Here is how they apply to LLMs:

Freedom How It Applies to LLMs
0: The freedom to run the program as you wish, for any purpose. You should be able to run any LLM on your own hardware, for any purpose—research, art, coding, or personal use. This means using free-weight models that you can execute locally.
1: The freedom to study how the program works, and change it so it does your computing as you wish. The model architecture and training methodology should be open for inspection. This is why freely licensed weight models (like DeepSeek, Mistral, Qwen) matter. You should be able to examine the weights, fine-tune them, and adapt them to your needs.
2: The freedom to redistribute copies so you can help others. You should be able to share the model weights and tools with others. This is the foundation of free software alike LLM.
3: The freedom to distribute copies of your modified versions to others. You should be able to fine-tune and customize models, then share those modifications. This is how the community improves collectively.

The crucial insight: None of these freedoms require the training data to be free. The model itself is a tool—like a compiler, a text editor, or a search engine. The tool’s value lies in its capability, not in the provenance of every byte it was trained on. A compiler does not need to know the origin of every line of code it processes; it just needs to work correctly.

What the Law Actually Says

Current case law—including the 2025 GEMA ruling in Germany and ongoing cases like Doe v. GitHub, Copilot—confirms:

  1. Training on copyrighted data is legally permissible. The Munich court explicitly stated that training itself is not the violation. The GEMA case focused on memorization and reproduction in outputs. The court found that “both the memorisation in the language models and the reproduction of the song lyrics in the chatbot’s outputs constitute an infringement of copyright exploitation rights.” But this ruling applies specifically to outputs, not to the training process.

  2. Copyright infringement occurs at the point of output and use. The user who reproduces, distributes, or publishes a substantial or expressive portion of a copyrighted work is the one who may be liable. If you ask for verbatim lyrics and then publish them in a commercial product, you are the one infringing.

  3. “Short” is not a safe harbor. Song lyrics—often only a few lines—were found to be infringing when reproduced. The court did not accept “it’s short” as a defense. The creative expression matters more than length.

  4. The legal landscape is still evolving. Appeals are likely (OpenAI has already indicated it will appeal the GEMA ruling), and new cases are working their way through courts. But the general trend is clear: the focus is on outputs, not on training data.

The key point for free software advocates: The law does not require models to be trained only on public domain data. We are legally free to create and use models trained on the full breadth of human knowledge. We do not need “safe,” “sanitized,” or “public-domain-only” models.

The False Promise of “Fully Free” Datasets

Some advocates argue that LLMs should be trained only on public domain or freely licensed data. This position is well-intentioned but misguided for several reasons:

Problem Explanation
Cultural impoverishment Excluding copyrighted works would gut the model’s knowledge of modern culture, literature, code, science, and current events. The model would be shallow, outdated, and largely useless for real-world tasks.
Impossible to verify As we established in our brainstorming, you cannot practically check the entire training set to verify that every piece is “free.” The effort would be enormous and the result would still be uncertain.
False safety Even a model trained only on free data can produce output that resembles copyrighted work (by combining free elements in a similar way). The safety is illusory.
Cripples the tool A model that refuses to quote or that sanitizes all outputs becomes evasive and untrustworthy. You cannot get a precise quote for research, nor can you verify what it knows. It is a tool that lies by omission.

The conclusion is clear: the hunt for “fully free” LLMs is a fool’s errand. We are already free by law to have LLMs trained on any kind of text. The real question is how we use that freedom.

Where the Real Problem Lies

The problem is not the model, nor the training data, nor even the provider. The problem is the user who shifts responsibility to the tool.

We have seen this pattern before in free software: - A compiler can generate code that infringes copyright if the user writes infringing code. - A search engine can return links to infringing content if the user searches for it. - A text editor can be used to copy and paste copyrighted text without permission.

Yet we do not demand that compilers or search engines be trained only on “safe” data. We do not demand that text editors refuse to paste text. We recognize that these are tools, and that the responsibility lies with the user.

The same logic applies to LLMs. A hammer can build a house or break a window; the hammer is not at fault. The user decides whether to copy a copyrighted lyric into a commercial product or to use it for personal research. The user is the agent, not the tool.

How I Use LLMs: A Personal Practice

As the author of this page, here is my personal practice, which you can adopt or adapt:

For Code

  1. I maintain a personal codebase with unique, hand-written functions. I use distinctive names like rcd-llm, hyperscope-add-generic, and hyperscope-isolate. These are not in any training data, so the LLM cannot rely on memorized patterns.

  2. The LLM must learn my API first. Because my foundational functions are unique and mostly written by hand, the LLM has to produce new, unique functions that extend my work. The output is a derivative of my original codebase.

  3. I treat the LLM as a junior assistant. It helps me extend my library, but I review, understand, and modify every suggestion. I never blindly copy-paste.

  4. I audit for licensing issues. If a suggestion looks like it might come from a known library, I check its license. I avoid copyleft (GPL) snippets in proprietary contexts.

  5. I document my process. I keep a log of which prompts produced which code. This helps establish authorship if ever questioned.

For Text and Creative Writing

  1. I use the LLM to brainstorm and break through writer’s block. It suggests alternative phrasings, outlines, and perspectives.

  2. I add my own context. I provide personal anecdotes, specific details, and original frameworks. The more of me is in the prompt, the more the output is my work.

  3. I never publish raw output. I always edit, fact-check, and add my own expression. The final work is substantially different from the raw output.

  4. I use verbatim quotes responsibly. If I need an exact quote for research or criticism, I cite the source. This is fair use. I do not use the LLM to extract and republish lengthy excerpts without permission.

  5. I keep a record of my prompts. This demonstrates transformative intent and shows that I was the author, not just a curator.

The Underlying Principle

In all cases, I treat the LLM as a tool that extends my creativity and knowledge, not as a substitute for them. I take full responsibility for the final work.

How to Generate Text That Doesn’t Infringe

If you want to use an LLM for writing while minimizing legal and ethical risk, follow these guidelines:

1. Transform, Don’t Copy

Bad Prompt Good Prompt
“Write a poem exactly like Maya Angelou’s ‘Still I Rise’.” “Write a poem about resilience in the face of adversity, using the metaphor of rising against gravity, in a rhythmic, empowering style.”
“Summarize the plot of Harry Potter.” “Write a story about a magical school but set it in a modern tech company, where the ‘wizards’ are skilled programmers and the ‘witches’ are managers.”

2. Add Your Own Context

Provide personal anecdotes, specific details, or original frameworks. The more of you is in the prompt, the more the output is your work.

Example: “Write a story about a programmer who discovers a bug in a legacy system. Use these details: the system controls traffic lights in my hometown, the bug appears at 3:17 PM every Tuesday, and the protagonist is a former musician.”

3. Treat Output as a Draft

Never publish an LLM output without editing, fact-checking, and adding your own expression. The final work should be substantially different from the raw output.

4. Use Quotes Responsibly

If you need a verbatim quote (for research or criticism), cite the source. This is fair use. Do not use the LLM to extract and republish lengthy excerpts without permission.

5. Keep a Record

Save your prompts and the process you used. This helps establish authorship and demonstrates transformative intent if ever questioned.

How to Generate Code That Doesn’t Infringe

Coding with LLMs requires special care because of licensing and the potential for “contamination.” Here is a clear, step-by-step guide:

Step 1: Build a Personal Foundation

Write your own hand-written, original functions first. Use distinctive, personal names that are not in any training data.

Example: Instead of sortArray(), use hyperscope-array-sort-custom(). Instead of generateHash(), use rcd-llm-secure-hash().

Step 2: Use the LLM to Extend, Not Create

Once you have a library of your own functions, ask the LLM to extend it. The model must learn your unique API before it can generate anything useful.

Prompt Example: “Using my hyperscope-array-sort-custom() function, write a new function called hyperscope-array-filter-unique() that removes duplicates.”

Step 3: Review and Understand Every Suggestion

Never copy-paste without review. Read every line. Ask yourself: “Does this look like it comes from a known library? Is it clearly derived from my own code?”

Step 4: Rewrite and Modify

Rewrite any part that looks like it might be lifted from another project. Change variable names, restructure logic, add your own comments. The goal is to make the code distinctly yours.

Step 5: Check Licenses

If you suspect a function is derived from a known library, check its license. Avoid using copyleft (GPL) snippets in proprietary code. Use permissive (MIT, BSD, Apache) if possible, or rewrite completely.

Step 6: Document Your Process

Keep a log of which prompts produced which code. This shows that you were the author, not just a curator. It also helps if you ever need to defend your work.

The User’s Responsibilities: A Clear Summary

Responsibility What It Means
Be aware of the law. Understand that copyright protects expressive works, and that reproducing them without permission can be infringement.
Be aware of the risks. Recognize that LLM outputs may be derived from copyrighted material, and that you cannot check the training data.
Transform, don’t copy. Use the LLM to generate new expressions, not to reproduce existing ones.
Add your own context. Provide personal, original details that the model cannot mimic.
Treat output as a draft. Never publish raw output. Edit, fact-check, and add your own expression.
For code: use unique names and review carefully. Build a personal library and treat the LLM as an assistant, not an author.
Take responsibility. You are the author, not the tool. Accept the legal and ethical consequences of your use.

Conclusion: The Freedom is Already Ours

We are free—by law, by technology, and by the Four Freedoms—to use LLMs trained on all of human knowledge. The only question is how we, as users, exercise that freedom.

We do not need “safe,” “sanitized,” or “public-domain-only” models. We need powerful, truthful, capable tools—and the maturity to use them wisely.

The freedom is already ours. Let’s use it well.

Copyright © 17th August 2026 by Jean Louis. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License”This article is licensed under the GNU Free Documentation License. You are free to copy, distribute, and modify it, provided you attribute the original author and share-alike.

Related pages