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


The LLM Freedom Manifesto: Open Weights, Permissive Training, and User Responsibility

The Conclusion of Our Reasoning

The discussion about “free” Large Language Models has become confused because several different things are being treated as if they were the same thing:

They are not the same.

An LLM is not simply a conventional software program. At its core, an LLM is a trained computational model: a collection of numerical weights and parameters produced through a statistical training process. The software used to train, run, fine-tune, and serve the model is a different thing.

The inference software can—and ideally should—be free software.

The model weights can be openly available and permissively licensed.

The training data can be public-domain, licensed, permissioned, or otherwise lawfully usable.

And the user can remain responsible for what the model ultimately produces and what the user does with that output.

These distinctions matter.

We do not need to pretend that an LLM is ordinary software in order to defend user freedom. We need to understand what an LLM actually is.

My conclusion is therefore somewhat different from the search for a mythical “perfectly free” LLM.

An LLM trained on permissive or otherwise lawfully usable data, with openly available weights and software that users can control, is an exceptionally valuable form of computational freedom.

Such a model gives users something important: control over the tool without requiring them to surrender their work to a remote service.

But freedom does not eliminate responsibility.

The model is the tool. The user is the agent.

And when the user publishes, distributes, sells, or otherwise relies upon the output, the user must take responsibility for that use.

1. What Is an LLM?

A Large Language Model is a trained computational system.

It contains numerical parameters—commonly called weights—that were adjusted during training so that the model can predict and generate language and, in multimodal systems, other forms of information.

The weights are not simply a copy of the training database.

They are the result of a computational learning process.

This is an important distinction.

Training data is not source code

Some people describe training data as the “source code” of an LLM and the weights as its “compiled binary.”

That analogy can be useful as a rough metaphor, but it is technically misleading.

Source code is a human-readable set of instructions written to specify a computer program.

Training data is different. It is material presented to a learning system so that the system can adjust its parameters.

The relationship is therefore not:

source code → compiler → executable

It is more like:

training material → training process → learned parameters

The resulting weights encode statistical relationships learned during training. They are not a conventional compiled version of the training corpus.

This distinction matters when discussing software freedom.

The GNU concept of free software was developed around the freedom to run, study, modify, and redistribute programs.

An LLM includes software, but its learned weights are a different category of computational artifact.

The correct question is therefore not:

“Are the weights literally software source code?”

The more useful question is:

“How much control and freedom does the user have over the software, model, weights, data, and resulting system?”

That is the question that matters.

2. The Four Freedoms and LLMs

Richard Stallman’s Four Freedoms provide an extremely useful philosophical framework.

The GNU Project defines free software around four essential freedoms:

  1. The freedom to run the program for any purpose.
  2. The freedom to study how the program works and change it.
  3. The freedom to redistribute copies.
  4. The freedom to distribute modified versions.

GNU Project — What is Free Software?

These freedoms were formulated for software.

An LLM is not identical to software, but the same principles can be applied to the complete LLM system.

Freedom 0 — Run it

A user should be able to run an openly available model locally or on infrastructure under their control, rather than being completely dependent on a remote provider.

This means:

Local execution is a major form of technological independence.

Freedom 1 — Study and modify it

Users should be able to inspect the architecture, understand the system, fine-tune the model, adapt it, and build upon it where the relevant licenses permit.

This is where open weights become extremely important.

A model that can actually be downloaded, inspected, fine-tuned, and adapted gives its users much more control than a model available only through an API.

Freedom 2 — Redistribute it

Where the license permits, users should be able to share model weights and the associated software.

This enables communities to preserve models independently of their original provider.

Freedom 3 — Distribute modifications

Users should be able to fine-tune, modify, merge, quantize, or otherwise adapt models and distribute those modifications when the applicable license permits it.

This creates a community of tools and users rather than a dependency on a single provider.

3. Open-Weight Is Not Automatically Free Software

This distinction should be made very clearly.

Open-weight does not automatically mean free software.

A model can have publicly downloadable weights while imposing restrictions on commercial use, redistribution, modification, or other activities.

Likewise, a model can be accompanied by open-source inference software while its weights are subject to a separate license.

Therefore, when evaluating an LLM, ask several separate questions:

Freedom requires reading the license, not merely looking for the word “open.”

4. Training Data Is a Separate Question

The provenance of training data matters.

This is where I would modify one of the strongest claims in earlier versions of this manifesto.

It is not accurate to say simply:

“Training on copyrighted data is legal.”

The legal position is more complicated.

Different countries have different copyright laws. Different exceptions apply to different activities. Different types of works create different questions. Licensing arrangements differ. And courts are still deciding important cases.

The U.S. Copyright Office is actively examining the copyright implications of LLM training, including licensing, training on copyrighted works, and allocation of liability.

The important conclusion is therefore not that every form of LLM training is automatically lawful.

The better conclusion is:

A LLM provider should use training material that it is legally entitled to use.

That can include:

This is where permissive training data becomes particularly important.

5. Why Permissive Training Data Matters

If an LLM is trained primarily on data that the provider has a clear legal right to use, the model begins from a much stronger position.

For example, imagine a model whose training corpus consists of:

That does not make the resulting model magically immune from copyright issues.

But it substantially improves the provenance story.

The provider can say:

“We had permission to use the material from which this model was trained.”

That is vastly more straightforward than:

“We copied everything we could find and hope the law permits it.”

This is why permissively trained LLMs are useful

A permissively trained model can provide an attractive combination:

capability + transparency + lawful provenance + user control

That combination is valuable.

We should therefore not dismiss the idea of permissive training data.

Quite the opposite.

As long as an LLM is trained on data that the provider is legally entitled to use—particularly public-domain or appropriately licensed data—that LLM is useful and can be an excellent foundation for genuinely user-controlled LLM.

The model does not have to contain every copyrighted work ever published in order to be useful.

It needs enough high-quality information to perform the tasks users actually need.

6. But Permissive Training Does Not Guarantee Permissive Output

This distinction is equally important.

Even if the training material is permissively licensed, an output can still create legal problems.

For example, a user might:

Therefore:

Permissive training improves the provenance of the model. It does not create a universal legal immunity for the user.

The user’s conduct remains important.

7. What Recent Legal Cases Actually Tell Us

This is where the manifesto needs to be precise.

The legal landscape is not settled.

For example, in Thomson Reuters v. Ross Intelligence, a U.S. federal court ruled in February 2025 that Ross’s use of Thomson Reuters' copyrighted Westlaw editorial material to develop a competing LLM legal research system was not protected by fair use. The case involved specific copyrighted editorial material and specific facts; it does not establish that every LLM training process is unlawful.

The case is important because it demonstrates precisely why the simplistic statement “LLM training is always fair use” is unsafe.

The GEMA/OpenAI litigation in Germany is another important warning.

In November 2025, the Munich Regional Court ruled in favor of GEMA in a dispute concerning copyrighted song lyrics and ChatGPT. GEMA reports that the court found copyright violations connected with the training and operation of ChatGPT in the circumstances before it.

An independent legal summary of the decision reports that the Munich court considered memorization within the model and subsequent reproduction of lyrics to constitute relevant acts of reproduction, while distinguishing the use of works in the creation of training material from the subsequent model-training process.

The lesson is not:

“LLMs are illegal.”

Nor is it:

“Training is always legal.”

The lesson is:

The legal treatment of LLM training depends on the jurisdiction, the material, the method of acquisition, the applicable exception or license, the model’s behavior, and the facts of the particular case.

That is a much stronger and more intellectually honest position.

8. The Copyright Office and Human Authorship

There is another important distinction: training an LLM system is not the same question as copyrighting the output.

The U.S. Copyright Office has stated that LLM-assisted works can receive copyright protection where a human author determines sufficient expressive elements. Merely providing prompts, by itself, is not necessarily sufficient to establish human authorship.

This reinforces a principle that is central to this manifesto:

The user should not treat the LLM as an autonomous author who magically transfers responsibility away from the human being.

The more meaningful human contribution there is—original ideas, selection, arrangement, editing, rewriting, factual knowledge, creative decisions, and other expressive contributions—the stronger the human authorship story becomes.

9. The User Is Not the Model

This is perhaps the most important principle in the entire manifesto.

When I use an LLM, I do not say:

“The LLM wrote it, therefore I am not responsible.”

I say:

“I used an LLM tool to help me produce this work, and I am responsible for what I ultimately do with it.”

That is the mature approach.

The LLM can be:

But it remains a tool.

The human decides what to accept.

The human decides what to reject.

The human decides what to publish.

The human decides what to sell.

The human decides what to deploy.

Therefore, responsibility cannot simply be outsourced to the machine.

10. Transformative Responsibility

I use the term transformative responsibility to describe this approach.

It means that the user does not simply take an LLM response and blindly publish it.

Instead, the user:

  1. supplies original context;
  2. asks questions;
  3. evaluates the answers;
  4. checks facts;
  5. identifies errors;
  6. adds personal knowledge;
  7. rewrites and restructures;
  8. adds original analysis;
  9. checks quotations and licenses;
  10. decides what finally becomes part of the published work.

The important word is responsibility.

“Transformative” should not be understood as a magical legal formula.

Simply changing words, variable names, or sentence order does not automatically eliminate copyright infringement.

Likewise, adding a prompt does not automatically make an output legally yours.

Transformation is a creative and intellectual process—not a legal loophole.

11. How I Use LLMs: A Personal Practice

For Code

I treat an LLM as a junior programming assistant.

I:

  1. maintain my own codebase;
  2. understand the architecture;
  3. give the model my own APIs and requirements;
  4. review generated code;
  5. test everything;
  6. check suspicious code against known libraries;
  7. examine relevant licenses;
  8. rewrite code where necessary;
  9. document important decisions.

I do not blindly copy code merely because an LLM produced it.

A model can produce excellent code.

It can also produce code that is wrong, insecure, inefficient, or suspiciously similar to existing material.

The responsibility remains mine.

12. For Text and Creative Work

My approach is similar.

I use an LLM to:

But I provide my own knowledge and context.

I edit the result.

I fact-check important claims.

I add my own examples and conclusions.

I decide what gets published.

The LLM therefore becomes an amplifier of my own intellectual work rather than a substitute for it.

13. Transform, Don’t Simply Copy

A useful practical principle is:

Ask the LLM to create from ideas and information, rather than asking it to reproduce protected expression.

For example:

Poor approach:

“Reproduce this entire copyrighted article.”

Better approach:

“Explain the central argument of this article and help me develop my own analysis of the subject.”

Or:

Poor approach:

“Write this exactly like a living author’s latest novel.”

Better approach:

“Write an original story involving these themes, characters, conflicts, and setting, without reproducing the author’s distinctive expression.”

The objective is not to make the model timid.

The objective is to make the user intelligent.

14. Keep Records

For important projects, I believe users should preserve:

This is useful not because keeping prompts magically proves copyright ownership—it does not—but because it creates a record of the creative and research process.

Documentation is evidence of process.

It is not a substitute for legal compliance.

15. A Better Way to Think About “Free LLMs”

The phrase “free LLM” can mean many different things.

It might mean:

These are not equivalent.

A truly user-friendly LLM environment should aim for as many of these freedoms as possible.

I therefore prefer to ask:

Can I run it?

Can I inspect it?

Can I modify it?

Can I redistribute it?

Can I fine-tune it?

Can I use it commercially?

Do I know where its training material came from?

Was the training material obtained permissively or under a clear legal basis?

Can I operate it without depending on a particular company?

These questions are much more useful than simply asking whether a model is “free.”

16. The Case for Permissively Trained Models

There is a particularly strong case for models built from permissively usable training material.

Such models can offer:

Legal clarity

The provider can explain why it was entitled to use the training material.

Ethical clarity

The model does not depend on pretending that creators' rights do not matter.

Technical freedom

Open weights can allow users to run and adapt the model locally.

Independence

Users can continue operating the model even if an online service changes its policies.

Reproducibility

Researchers can examine and reproduce more of the system.

Community development

Developers can build specialized versions for particular industries and languages.

Long-term preservation

A downloadable model can survive independently of the company that originally released it.

This is the direction I would like to see.

Not “LLM without rules.”

Rather:

Powerful LLM with transparent provenance and meaningful user freedom.

17. We Should Not Confuse Safety With Dependence

There is another danger.

A company may say:

“Our model is safe because you cannot download it, inspect it, or modify it.”

That is not the same as freedom.

A closed model may have excellent safety controls.

It may also have excellent capabilities.

But users remain dependent upon the provider.

The provider controls:

Open models create another possibility:

Users can take responsibility for the tools they operate.

Freedom means accepting responsibility as well as receiving power.

18. The User’s Responsibilities

The mature LLM user should therefore accept the following responsibilities.

Responsibility What it means
Understand the tool Know whether you are using a closed model, open-weight model, or genuinely free software system.
Check the license Understand what you are legally permitted to do with the model and its weights.
Prefer good provenance Prefer models whose training data has a clear, permissive, licensed, or otherwise lawful provenance.
Verify important information LLMs can confidently produce false information.
Do not blindly reproduce protected material Generated text is not automatically free of copyright restrictions.
Add human judgment Review, edit, restructure, and improve the output.
Respect third-party rights Copyright, privacy, confidentiality, trademarks, and other rights still matter.
Maintain your own work Keep your own source files, drafts, research, and codebase.
Document important processes Maintain useful records when the project is commercially or legally significant.
Accept responsibility The fact that an LLM generated something does not automatically excuse the person who uses it.

19. The Real Freedom

The real freedom is not:

“I can make the LLM do anything without consequences.”

That is not freedom.

That is irresponsibility.

The real freedom is:

“I have access to a powerful tool, I understand how it works, I can control it, I can modify it, I can preserve it, and I accept responsibility for how I use it.”

That is a much more mature concept of technological freedom.

20. Our Position

We therefore reject two extremes.

Extreme one: “Every LLM must be trained only on public-domain material.”

This may unnecessarily restrict the development of capable models and is not a universal requirement of copyright law.

Extreme two: “Training on anything is automatically legal.”

That is equally wrong.

Copyright law is jurisdiction-specific and fact-specific, and recent cases demonstrate that unauthorized use of copyrighted material in LLM development can create real liability.

Our position is between these extremes:

Use the broadest lawful and useful training material possible, preferably with clear and permissive provenance. Build models with open weights and genuinely usable licenses where possible. Give users control of the software and model. Then put responsibility where it belongs: on the human beings who decide how the technology is used.

21. The LLM as a Tool

A hammer can build a house.

It can also break a window.

We do not therefore demand that every hammer be incapable of breaking glass.

A compiler can produce a program containing a bug.

A text editor can be used to reproduce copyrighted material.

A search engine can locate material that someone should not copy.

The existence of a tool does not eliminate the responsibility of the person using it.

The same principle applies to LLMs.

The important difference is that an LLM is an extraordinarily powerful tool.

That makes responsible use more important—not less.

22. The Freedom Is Already Within Reach

We do not need to wait for a mythical perfect LLM model.

We can build a better foundation for LLMs now.

We can support:

An LLM trained on permissively usable data and released with genuinely useful freedoms is already a powerful instrument.

It does not need to be perfect.

It needs to be useful, transparent, controllable, and responsibly used.

Conclusion: Freedom and Responsibility Belong Together

The debate about “free LLMs” should move beyond slogans.

An LLM is not simply a piece of conventional software.

Its weights are not its training corpus.

Its training data is not automatically its “source code.”

Its output is not automatically free of copyright restrictions.

And its user cannot simply transfer responsibility to the machine.

At the same time, users should not be forced into permanent dependence on centralized LLM providers.

Open weights matter.

Free software matters.

Permissive training data matters.

Transparent provenance matters.

Human authorship and responsibility matter.

And these principles can coexist.

My preferred model is therefore:

A powerful LLM, trained on data that the provider is legally entitled to use, preferably with permissive or transparent provenance; released with genuinely useful freedoms; runnable by the user; modifiable by the community; and used by people who accept responsibility for the resulting work.

That is not a demand for “sanitized LLM.”

It is not a demand for weak LLM.

It is not an argument that every copyrighted work must be excluded from every conceivable training process.

It is an argument for freedom with responsibility.

The machine does not become the author simply because it generated the first draft.

The provider does not become responsible for everything a user subsequently publishes.

And the user does not become powerless simply because the tool is sophisticated.

The LLM is the tool.

The human is the responsible agent.

The quality of the result depends on both.

The freedom is not something we should fear.

The freedom is something we should learn to use.

Let’s build powerful LLM.

Let’s build LLM with better provenance.

Let’s build open models wherever possible.

And let’s be responsible enough to use that freedom well.

Important legal note

This manifesto expresses a technological and philosophical position; it is not legal advice. Copyright law differs between jurisdictions and continues to develop as courts and legislators address LLM training and outputs. The U.S. Copyright Office is continuing its LLM/copyright work, while recent decisions such as Thomson Reuters v. Ross Intelligence and the Munich GEMA/OpenAI case demonstrate that the legal questions cannot be reduced to a single universal rule.

For the latest primary-source material, see the U.S. Copyright Office’s AI and copyright project and the GNU Project’s definition of free software.

Copyright © 17 August 2026 by Jean Louis.

This article is licensed under the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation, with no Invariant Sections and no Front-Cover or Back-Cover Texts. A copy of the license should accompany this document.

Related pages