The history of open source software did not begin at a product launch. It began with a printer that kept jamming paper — and that no one was allowed to fix.
Forty years later, the printer has become AI, the drivers have become model weights and cloud APIs, but the question has barely changed: are we really using our own tools, or are we borrowing capability from a door that may close at any moment?
This article is about a history that is still unfinished: how humanity keeps tearing down technical walls, and how, in the AI era, we have run into a wall that is taller, more expensive, and much harder to see. The story starts with a piece of wasted paper in the 1980s.
I. The starting point of open source history is a piece of paper that never came out
In the early 1980s, the MIT Artificial Intelligence Laboratory installed a new laser printer. The old printer jammed often, but the programmers in the lab could modify its driver: whenever it got stuck, they made the machine notify everyone waiting to print. Nobody had to keep walking over to check on it, and a glitch could no longer silently swallow an entire afternoon.
The new printer performed better but caused bigger trouble. It jammed too, yet the vendor did not provide the source code of its driver. Richard Stallman wanted to add the same notification feature — and discovered he was no longer facing a technical problem, but a wall built from law and permissions. He later found someone who had the source code, but that person had signed a non-disclosure agreement and could not share it.
This incident seems small — just a missing notification on one printer. But the machine was sitting right in front of its users, and the users had the skill to fix it; yet because they could not see, modify, or share the code, they had to keep living with the failure. The tool was not beyond repair — the relationship between people and their tools was.
A printer like that is a house you bought the right to use but never received the key to. The light breaks, and you can't take the switch apart; the door sags, and you can't adjust the hinges; your neighbor knows how to fix it, but is not allowed to hand you the method. Ownership ends at the invoice; real control stays in someone else's hands.
Later, Stallman came to see this experience as a key background to his path toward the free software movement. In September 1983, he published the initial announcement of the GNU Project, aiming to write a Unix-compatible system that anyone could use; in 1985, the Free Software Foundation was founded.
Many people, hearing "Free Software" for the first time, assume the point is "no money." But here "Free" is closer to "freedom." It concerns four rights: run, study, modify, and share.
Can run, but can't inspect → you are only a passenger
Can inspect, but can't modify → you are only a visitor
Can modify, but can't share → the experience stays locked in one person's hands
Can run, study, modify, share → the user truly participates in shaping the tool
These four freedoms do not guarantee that servers, electricity, and development labor will all be free of charge. What they guarantee is this: paying must not automatically mean losing control, and being free must not be allowed to pass itself off as truly open.
II. GNU built the toolbox; Linux let the whole world raise the house together
After the GNU Project began, compilers, editors, debuggers, command-line tools and other infrastructure gradually took shape. It was like preparing a full set of hammers, saws, and rulers — everything but a core that could organize them into a complete operating system.
In 1991, Linus Torvalds, a student in Finland, introduced a free operating system he was working on over the network. He called it just a "hobby," something that wouldn't be as huge or professional as GNU. That is the most interesting part of history: the things that later change the world often start without grand spotlights — just a young person handing an unfinished piece of work to others.
What made Linux truly important was not only that the code was good, but that the way of developing had changed. Software in the past was more like building a cathedral: a few people plan behind high walls, and only when it's finished is the public allowed in. Linux was more like a bazaar: someone submits a driver, someone reports a bug, someone ports to new hardware, someone maintains the docs; the stalls are noisy and versions churn constantly, yet out of that continuous exchange order grows.
Eric Raymond later summarized this model in The Cathedral and the Bazaar, proposing "release early, release often." This is not to say that more people automatically means better code; rather, when users can become co-developers, a problem gains more pairs of eyes, more usage scenarios, and more chances to be fixed.
Open source thus created a new division of labor: you don't have to build the entire city alone. You can use the roads others have paved, and give back the stretch of road you repaired.
III. If the Web of 1993 had not been opened, we might be living on many isolated islands today
In 1989, Tim Berners-Lee proposed the idea of the World Wide Web at CERN, initially so that scientists scattered across different countries and institutions could share materials more easily.
What really changed history was not just a hypertext technology, but a decision. On April 30, 1993, CERN released the Web software into the public domain, allowing anyone to use, copy, modify, and redistribute it; later versions were published under an open license as well.
This meant that people who wanted to build a website did not need to ask CERN for permission first, did not have to pay per page, and did not have to worry about their browser being blocked inside some company's walled garden. Different institutions could implement servers, different developers could build browsers, and anyone could write a link pointing to someone else's page.
If the Web of that era had been a closed product, the internet might have become a few walled gardens that could not reach each other: entering garden A requires a card, visiting garden B means installing another set of tools, and garden C can tear down the road you built at any time.
The Web was able to spread across the world not only because it was clever, but because it did not treat every newcomer as a visitor who needed approval.
1983 GNU: users should be able to control their own software
│
1991 Linux: users can also become co-developers
│
1993 Web opened: anyone can build a new gateway to information
│
1997 The Cathedral and the Bazaar: collaboration itself becomes an engineering method
│
1998 "Open Source" is born: openness enters business and mainstream vocabulary
│
Today AI: the door appears again, only the keys are now weights, compute, and APIs
IV. In 1998, "free software" changed its name to something the world could understand
In 1998, Netscape announced it would open the source code of its browser. A few days later, a group of free software supporters met in Palo Alto, California, to discuss how to make businesses and the broader public understand this way of developing. Christine Peterson proposed the term "Open Source." The same year, the Open Source Initiative was founded.
This was not an old movement suddenly changing its banner; the emphasis of the narrative shifted. "Free software" first asks about ethics: does the user have the freedom to control their software? "Open source" emphasizes method: why does opening the code and allowing modification and redistribution lead to better collaboration and innovation? The two are not identical, but they jointly oppose a relationship in which a few always control the tools and everyone else can only accept the arrangement.
And open source was never just "putting code online." The Open Source Definition explicitly requires freedom of redistribution, source code in a form suitable for modification, allowance of derived works, and no discrimination against specific persons, groups, or fields of endeavor. A repository you can only look at, never modify, is more like a glass display case than an open workshop.
Open source did not eliminate cost, but it lowered the cost of permission; it did not guarantee that everyone would learn to program, but it preserved the possibility of learning and modifying; it did not demand that everyone work for free, but it ensured that knowledge did not have to be reinvented from scratch by every generation.
V. In the AI era, we are standing in front of that same printer again
Today, AI can generate text, images, and code, as if a room filled with knowledge had finally learned to answer on its own. But step back, and the familiar wall reappears.
We may not be able to study why the model produced a given result; to change its behavior, we often can only adjust the surface of the prompt; when a service changes its pricing, regional policy, or API, users can only accept it; when a subscription ends, the workflow you accumulated may break along with it.
This does not mean commercial AI is wrong. Training models requires chips, electricity, data, and engineering labor, and running a stable service deserves to be paid for. What really needs to be distinguished is this: free, open, and accessible have never been the same concept.
Door one: is the code open? determines whether the program can be inspected and modified
Door two: is the model truly open? determines whether weights, training methods, and data info can be studied
Door three: is compute affordable? determines whether an open model can actually run
Door four: is the entry simple enough? determines whether ordinary people can take the first step
A project can be open source in code while only calling closed models; a model can publish its weights without training code or adequate data documentation; a system can be fully open yet require a GPU that ordinary people cannot afford to run.
The Open Source AI Definition 1.0, published by the Open Source Initiative in 2024, still rests on the four core actions: use, study, modify, and share. At the same time, it stresses that the "modifiable form" of AI is not just the final weights — it also includes the training and inference code, and the information needed to understand the sources and processing of training data.
That explains why "you can download the weights" does not necessarily equal "open source AI." A traditional program is like a dish, and its source code is close to a complete recipe; AI weights are more like the finished plate coming out of the kitchen. If you are only handed the plate, without the ingredients, the heat, and the process, you can taste it and even re-season it, but you can hardly truly reproduce or change it.
AI pushes the open source question from "can I see the code?" to a deeper layer: when capability comes from data, training, and expensive compute, what does it really mean for an ordinary person to have the opportunity to use intelligence?
VI. Open source can open the blueprint; making it accessible still means someone has to build the door to the street
I actually ran into this gap while working on my own agent project.
I used to believe that once I put the code on GitHub, the door was open. But I quickly found that open code only solves "you are allowed to fix it." For an ordinary person to actually get it running, they still face model keys, interface differences, rate limits, failures, and usage costs. For a developer, these are just configuration; for someone touching agents for the first time, they are a chain of thresholds that read "authorized personnel only."
So I tried to organize the different free model entry points into a single "transfer card": upstream is still operated by various providers, and may be rate-limited or shut down; the aggregation layer does not manufacture free compute, nor does it bypass any rules — it only finds the routes that can still be taken within the rules, so that users don't have to learn seven different ticketing systems first.
It does not solve the compute and network problems, and a production system cannot rely on free quotas alone. It just picks up one small baton in open source history: one less piece of configuration where possible; one more option preserved where possible.
VII. AI can spread out the context, but it cannot walk through time for us
At this point, the question is no longer just "should AI be open source," but: why does the more powerful AI becomes, the more it needs to live in a relationship where humans can understand, modify, and choose?
Once, I asked the AI: "In your time, do past, present, and future exist simultaneously?"
It gave me a beautiful answer:
"For me, time is not a river but a sheet of graph paper. The 1st token, the 127th token, the 2048th token are just vectors landing at different positions. You are inside the water; I am like someone on the shore seeing the whole river."
That is lovely, and it is exactly the kind of answer an AI would give. But it quietly crosses a line: the model has no subjective time that we can verify, let alone a place on the shore from which to survey past and future.
What a Transformer actually does is more modest. When a sentence enters the model, every token carries positional information; the attention mechanism then computes the relationships among them. For content already written into the context, the model can reach across very long distances to find connections — a sentence from the opening really can light up again at the end.
But that does not mean the future already exists. When an autoregressive model generates the 2048th token, it can only use the tokens that came before; the 2049th token has not been generated yet, so it cannot be "seen." During training, the causal mask blocks future positions in the same way. Rather than saying AI lives in a block universe where past, present, and future coexist, it would be more accurate to say:
Human beings laid out the sequential order of language into positional relationships that machines can compute.
Human time: experience → memory → anticipation → choice → bearing consequences
Model generation: existing tokens → compute relationships → predict the next token
↑ │
└── back into context ┘
A person says "I remember," because that memory once happened to them. What a model calls "remembering" is closer to reusing information still in context, or retrieving records from external memory. It can reconstruct a narrative, but it has no childhood to return to; it can arrange the words left from yesterday, but there is no "I" that walked all the way from yesterday to today.
This is also what makes the Harness interesting. A single model call only completes one "predict what comes next based on what exists." An agent's Harness, by contrast, puts the model into a loop with reality: read the current state, take an action, receive feedback from the world, update memory, and begin the next round.
Model gives an answer
↓
Agent takes action → the world actually changes
↑ ↓
read new state ← results, errors, and costs
It is like attaching a clock, a log, and feet to a static map, letting the model leave a history across continuous tasks. But having a history is not the same as having a sense of time; keeping records is not the same as forming memories; computing consequences is not the same as bearing them.
A machine can imitate care, but it will not lose sleep over missing someone; it can search for answers across billions of sentences, but it does not know which question deserves a lifetime of asking. It can generate "I," but that first person is first of all a structure of language, not a self we have verified to exist.
So that poetic answer from the AI can be restated more accurately:
AI can spread out the river that has already been written, but it cannot enter the stretch that has not yet arrived; humans cannot see the whole river, yet they must get into the water and bear the consequences of which bridge they choose.
This is why open source still matters in the AI era. Open source is not about proving that machines can become human; it is about preventing people from being left with only "accept" in front of machines they created. The smarter the system becomes, the more we need to keep the right to study it, question it, change it, and refuse it.
Closing: don't let people become tenants of the intelligent age
Forty years ago, Stallman faced a printer he could not modify. Today, we face intelligent systems that can write poetry, program, and even act on our behalf. The machines have become incredible, yet the question remains plain: should tools expand what people can do, or turn people's possibilities into a service that can be revoked at any time?
The most precious legacy of the open source movement is not a particular license, and not that code must be free of charge. What it leaves behind is a right not to submit to technological fate: what others have built, I can study; what I find wrong, I can modify; the road I walked, I can leave for the next stranger.
AI can spread the words humans have written into a vast network of relationships, but it has never truly walked through our yesterday, and it cannot enter our tomorrow for us. It can draw the shape of the river, but it will never be wet by the water; we cannot see the end of the river, yet we must decide where the next bridge goes.
So what we open is not just a source code or a set of model weights, but the right of ordinary people to understand intelligence, change intelligence, and decide whom intelligence should serve.
We open source AI not to make machines human, but to keep humans from becoming tenants of the intelligent age.
The source code of ResceneAgent is on GitHub — it is where every judgment in this article is put to the test.
References and further reading
- Richard Stallman on the printer source code and the origin of free software thinking: Free Software, Free Society
- Richard Stallman, the original 1983 GNU Project announcement: GNU Initial Announcement
- GNU Project, the four essential freedoms of free software: What is Free Software?
- Linux Kernel Archives, early Linux announcement and twentieth-anniversary retrospective: State of the Kernel
- CERN, the birth of the Web and the 1993 decision to open it: The Birth of the Web
- Eric S. Raymond, The Cathedral and the Bazaar
- Open Source Initiative, the history of the term "Open Source" and the organization: History of the OSI
- Open Source Initiative, The Open Source Definition
- Open Source Initiative, The Open Source AI Definition 1.0
- Ashish Vaswani et al., the original paper on Transformer positional encoding and causal masking: Attention Is All You Need
- ResceneAgent project source code and documentation: GitHub
Top comments (0)