Linus Torvalds Has a Hallucination

A twenty-year-old in a cold Helsinki apartment thinks the entire trillion-dollar architecture of machine intelligence is in bad taste. He may be the most dangerous kind of person in tech: the kind who is bored.

Helsinki after midnight. The city where this keeps happening.

An editor's note on this story. What follows is a work of speculative journalism. The historical record here — the 1991 Usenet post, the GPL relicensing, the "good taste" lecture, the Open Source AI Definition, the state of the 2026 model ecosystem — is reported. The twenty-year-old Helsinki student named Linus Torvalds who appears in these pages is not. He is a thought experiment given a body, a name, a bad chair, and a caffeine problem: the 1991 hacker, respawned into 2026, aimed at a different monolith. The real Linus Torvalds is fifty-six, lives in Portland, and is responsible for none of this. Everyone else in the apartment is invented. The stakes are not.

I. The Function That Did Not Exist

It is 3:14 in the morning in the Kallio district of Helsinki and the machine is lying to him. This is the working class part of the town, and as honest Finns go, lying is considered worse than murder.

Not maliciously. Not even interestingly. It is lying the way a very confident undergraduate lies — smoothly, in complete sentences, with correct indentation, in a tone of such total institutional serenity that for eleven full seconds the kid at the desk believes it. The model has produced forty-one lines of Python. The forty-one lines are beautiful. They import a function called torch.distributed.all_reduce_sparse_hybrid.

There is no such function.

There has never been such a function. There is no RFC proposing such a function, no deprecated branch where such a function briefly lived, no mailing-list thread where a maintainer in Trondheim once wished aloud for such a function. It is a pure invention, conjured out of the statistical fog between all_reduce, sparse, and hybrid, three tokens that have simply spent enough time near each other in the world's scraped text to fall in love and produce offspring.

The kid — twenty years old, hair like something that lost an argument with a pillow, wearing a hoodie from a Nokia hackathon he did not attend and got the hoodie anyway — stares at it. The room hums. Two consumer graphics cards, bought used on a boat trip to Tallinn, breathe out heat at the back of a case with one side panel missing, whirrrrr, and the heat rolls across the desk and up over a plate with the fossil of a rye sandwich on it, and out the window the Baltic dark presses against the glass at a temperature that Finns describe, in August, as "mild."

Eleven seconds. That is the part that will bother him for weeks. Not that the model hallucinated. Everyone knows the model hallucinates; hallucination is the industry's favorite word for it, a soft word, a spa word, a word that makes a false statement sound like a religious experience rather than a defect. No. What bothers him is that for eleven seconds he believed it, and the reason he believed it is that the lie was well-formatted.

He does not swear. (This is the first thing everyone gets wrong about him. The famous one swore. This one goes very, very quiet, which the people who work with him have learned is worse.) He opens a text file. He types one line, all lowercase, no punctuation:

the model is not the problem the architecture is the problem

Then he goes to bed. He does not sleep. Nobody in this story sleeps very much; that is more or less the point of the story.

Six weeks later he will post something to a forum, and a certain number of very expensive people in Menlo Park and Mountain View and Redmond will read it and feel an unfamiliar sensation in the base of the skull, a sensation their predecessors felt in 1991 and again in 1998 and again in 2008, and which has no good name in English but might be rendered as: oh no, a bored person with taste.

II. The OG

Hardware of the era the announcement was typed on. The 80386's task-switching was, the man said, "just a hobby."

To understand why a twenty-year-old in Kallio thinks he can walk up to a two-trillion-dollar industry and inform it that its data structures are ugly, you have to go back thirty-five years and about three kilometers due south, to another Helsinki apartment with another terrible chair.

On August 25, 1991, a twenty-one-year-old computer science student at the University of Helsinki named Linus Benedict Torvalds posted a message to the Usenet newsgroup comp.os.minix. It is one of the most consequential documents of the twentieth century and it opens with an apology:

"Hello everybody out there using minix — I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu) for 386(486) AT clones. This has been brewing since april, and is starting to get ready. I'd like any feedback on things people like/dislike in minix, as my OS resembles it somewhat (same physical layout of the file-system (due to practical reasons) among other things)."

Read that again and notice what is not in it. There is no mission. There is no manifesto. There is no promise to liberate the computing masses from the yoke of proprietary vendors. There is a young man who wanted to understand how the Intel 80386 switched between tasks, who got interested, who kept going, and who had already ported bash 1.08 and gcc 1.40 and figured somebody might want to try it.

The ideology was already in the building, and it belonged to somebody else. In September 1983, Richard Stallman had announced the GNU Project — GNU's Not Unix — a movement founded on a moral claim: that software users are entitled to run, study, modify, and share the code that governs their lives. Stallman had the philosophy, the license theory, the four freedoms, the beard, the absolutism. What Stallman's project did not have, after eight years of trying, was a finished kernel.

So the moral revolution of the late twentieth century was completed by a Finn who was, by his own account, mostly just curious. In 1992 Torvalds relicensed the kernel under the GNU General Public License, and the two halves snapped together with a click you can still hear: Stallman's copyleft legal architecture wrapped around Torvalds' pragmatic engineering architecture. Freedom, enforced by contract, powered by somebody's hobby.

What happened next is the part everyone forgets to be amazed by. By 1993 there were more than a hundred core developers. Slackware and Debian appeared. By 1998, IBM, Compaq, and Oracle — companies whose entire institutional personality was proprietary — were announcing commercial support for a student's side project. Linux climbed into supercomputing. Eric S. Raymond wrote The Cathedral and the Bazaar and coined the line that became the movement's physics: "Given enough eyeballs, all bugs are shallow." Linus's Law. Not a slogan. A claim about the thermodynamics of attention: that distributed, transparent scrutiny beats hierarchical, secret scrutiny, reliably, over time, at scale.

It is thirty-five years later and every hyperscaler on earth runs on that hobby. Your phone. Your car's infotainment. The training cluster of every frontier AI model — every single one, without exception — boots Linux before it boots anything else. The proprietary AI industry of 2026 is a cathedral built on top of a bazaar and, for the most part, it does not think about this much.

The twenty-year-old in Kallio thinks about it constantly. It is, he will tell you, the whole joke.

III. Good Taste

Somewhere in here is a branch that shouldn't exist. The argument that has ruined more job interviews than any other.

In 2016, on a TED stage, Chris Anderson asked the real Torvalds what he actually meant by "taste" in code. Torvalds did something almost nobody does on a TED stage: he answered with a linked list.

Here is the problem. You have a singly linked list. You want to remove one item from it. The textbook solution — the one taught in a thousand undergraduate lecture halls — looks like this:

void remove_entry(list *head, node *target)
{
    node *walk = *head, *prev = NULL;

    while (walk != target) {
        prev = walk;
        walk = walk->next;
    }

    if (!prev)                 /* <- the special case */
        *head = target->next;
    else
        prev->next = target->next;
}

It works. It is also, Torvalds argued, in bad taste. Look at that if. It exists for exactly one reason: the head of the list is not stored the same way every other link is stored. The head lives in a variable; every other link lives inside a node. So the head becomes an edge case, and the edge case demands a branch, and the branch demands a test, and the test demands a comment, and five years later somebody adds a second branch next to the first one, and now you have a bug that only manifests on Tuesdays.

Now the version with taste:

void remove_entry(list **head, node *target)
{
    node **indirect = head;

    while (*indirect != target)
        indirect = &(*indirect)->next;

    *indirect = target->next;   /* that's it. that's the function. */
}

A pointer to a pointer. The head is no longer a special place — it is just the address of a slot that holds a node pointer, and so is every next field in the list. Same type. Same operation. The if is gone, and it is not gone because it was cleverly hidden; it is gone because it was never necessary once the data was modeled correctly.

That is the whole doctrine, and it fits on a napkin: bad programmers worry about the code; good programmers worry about data structures and their relationships. Special cases are not features of reality. Special cases are receipts for a modeling mistake you made earlier and have not yet admitted.

Torvalds applied the same structural instinct to his second world-altering project. Git does not store diffs and reconstruct your history by replaying them. Every blob, every tree, every commit is an immutable object whose name is the hash of its own contents. Content-addressed. Which means integrity isn't a feature bolted onto Git — integrity is what Git is. Corrupt a byte and the name stops matching the thing. No checker required. No special case.

Hold that thought, because in about three thousand words a twenty-year-old is going to point it, like a rifle, at the transformer.

IV. The Great Open-Washing

Sealed, labelled, and stacked. "Open" is a word that has been doing a lot of unpaid labour.

While the capital poured in, a quieter and more consequential fight was happening over a single word.

Open source has always had a clean physics: source, compiler, binary. Hand me the source and the licence and I can study, change, and rebuild the thing. A neural network detonates that. What, exactly, is the "source" of a model — the training code, the filtering scripts, the two hundred billion numbers that fell out of a nine-figure electricity bill? Ship someone the weights and you have shipped a binary artefact of unknown provenance, unauditable as to how it came to believe what it believes.

So on October 28, 2024, after a consultation that was less a drafting process than a two-year knife fight conducted by email, the Open Source Initiative wrote down what the word means now. The Open Source AI Definition 1.0 grants the four freedoms that always governed software — use it for any purpose without asking, study it, modify it, share it — and, to make them exercisable rather than decorative, demands three things:

Code. The full training and inference pipeline, under an OSI-approved licence. Not just the inference stub.

Parameters. The weights, under terms permitting free and unrestricted use. No "unless you compete with us."

Data information. Enough detail about the training data that a skilled person could build a substantially equivalent system.

The third pillar is where the fight lives, and where the OSI made a compromise the purists have never forgiven. The trap is symmetrical: demand every raw byte and the definition is unsatisfiable, since law makes much of any real corpus illegal to redistribute; ignore data and you legitimise the opacity you set out to break. So the OSI split it. Freely shareable data must be shipped. Public or purchasable data must be disclosed precisely enough that a stranger could go and get it. Genuinely locked data — patient records, regulated personal information — must be described exhaustively enough that someone could build an equivalent out of different material. You may keep the data, but you may not keep the secret.

That is the yardstick. Now the measurement.

Both middle rows have been marketed as the bottom one. The second fails plainly: the moment a licence enumerates purposes you have built a permission system, and you may call it anything except open.

The third is the interesting one. Around 2025 the Chinese labs did something almost nobody predicted — they stopped playing licence games. Not ideology but strategy: if you are late and the incumbent's moat is distribution, you attack it by making your product legally frictionless. DeepSeek put its 1.7-trillion-parameter V4-Pro weights out under a plain MIT licence; Alibaba shipped Qwen3.8's small and mid tiers under Apache-2.0. A hospital whose lawyers will not sign a purpose restriction can deploy DeepSeek without a conversation. But look where those same labs land in both middle rows above: the split is not national but commercial. The licence loosens in inverse proportion to what the model is worth as a product.

Now apply the third pillar. Open a model card for any of them and you get architecture, benchmarks, deployment instructions, a licence file. Scroll for the training corpus and you get nothing — no manifest, no provenance, no list of what was scraped, licensed, bought, or synthesised. On the pillar the OSI spent two years arguing about, the three upper rows are indistinguishable. The licence problem is closer to solved than anyone expected; the transparency problem has not moved at all. Which is why the list of systems that actually cleared the standard fits in one breath: Ai2's OLMo, EleutherAI's Pythia, LLM360's Amber, Google's T5.

Every model with a household name sits in a middle row — including the one the twenty-year-old in Kallio runs on. He is not sentimental about it. It is the best available substrate and it is not open source, and he can hold both of those at once, which is more than most of the industry manages.

V. Kallio, 04:20, and the Shape of the Complaint

The entire operation. Two screens, one lamp, and a fan that never stops.

Back to the apartment. Back to the boy and the lying machine.

His name really is Linus Torvalds. This is less remarkable in Finland than you think — there are Linuses in Finland the way there are Michaels in Ohio — but it has followed him since he was nine and a teacher read the roll and paused, and it has produced twenty years of the same joke told by the same kind of person at the same volume. He has a stock response. He shrugs and says, "Different family." Then he changes the subject, and if you watch his face while he changes the subject you can see something he does not intend to show you: he is so tired of being a punchline that he has begun, somewhere behind his eyes, to consider the alternative.

He has been watching this industry since he was fourteen, which is to say he has watched it exclusively in its current form: enormous, capitalized, certain of itself, and — this is the part he cannot stop noticing — perpetually repairing itself from the outside. Every release cycle, another layer. Never a smaller thing that needed fewer layers.

He shares a two-room flat with a molecular biology student named Minna who has been awake for the last forty minutes because the graphics cards ramped up again and the wall between the rooms is, generously, a suggestion. She has a strategy for this. She stands in the doorway with a blanket around her shoulders and does not say turn it down. She says: "What did it do."

"Made up a function."

"So?"

"So I believed it."

Minna, who spends her days watching cell cultures do statistically plausible things that turn out to be contamination, thinks this is the least surprising sentence she has ever heard, and says so, and goes back to bed. But she has done the thing she always does, which is force him to say the complaint out loud, and the complaint — once it is out loud, at 4:20 in the morning, in a cold room that smells like hot silicon — turns out not to be about hallucination at all.

The complaint is this. The industry has built an enormous machine for producing plausible text and then wrapped it in a growing shell of patches to stop it from producing the plausible text you didn't want.

Consider what a frontier proprietary system in 2026 actually is, structurally, if you strip the branding off:

• a base model, trained on a corpus nobody outside the company has seen;
• a router that decides which of several models should answer, based on heuristics;
• a system prompt of several thousand words, hand-tuned, containing instructions that contradict each other;
• a preference-tuning layer that reshapes the outputs toward a taste profile assembled by contractors;
• a set of classifiers that inspect the output and sometimes suppress it;
• a retrieval layer, bolted on, to compensate for the model not knowing things;
• a tool-calling layer, bolted on, to compensate for the model not being able to do things;
• and around all of it, a terms-of-service document that is, functionally, the last exception handler.

Look at that list the way Torvalds looked at the linked list.

Every single one of those layers is an if. Every one of them exists to handle an edge case that the underlying architecture generates and cannot itself resolve. The system prompt is a special case. The router is a special case. The classifier is a special case wearing a lab coat. The industry has not built an elegant data structure and then used it. It has built something that mostly works, discovered a thousand edge cases, and stapled a conditional to each one — and then, in the finest tradition of software that has outgrown its own design, hired a policy team to name the staples.

"They keep patching the head of the list," the kid says. "Nobody wants to change the pointer."

VI. Where the if Is Hiding

Notation is a costume. Write a special case in chalk and symbols and it stops looking like a special case.

Here is the part where — if you have ever written a line of code in your life — you feel the floor tilt slightly. You do not need the notation. You need one idea.

The engine underneath every model in this story is called attention, and it is embarrassingly simple: for every word, it looks at every other word and decides how much each should count. "Bank" looks around, sees "river" three words back, weights it heavily, and settles into riverbank rather than a place that holds money. It is one of the great ideas of the century, and you can explain it at a bus stop.

But a language model writes left to right, and there is a rule: when it is working on word five, it must not look at word twelve. Word twelve hasn't been written yet. If the model can see it during training it learns to cheat, and at that point you don't have a model, you have a very expensive photocopier.

So how is the rule enforced?

It is enforced by building the full grid anyway — every word against every other word, the future included — and then crossing out the half that isn't allowed. Every forbidden pairing is stamped with a value meaning never. The good implementations are cleverer than that — the fast kernels never build the forbidden half, they decline to loop over it — but cleverer is not the same as gone.

Sit with that for a second, because the kid did, for most of a winter.

The grid is built wrong, and then it is corrected. The structure has no notion of time, so time is imposed afterward, by hand, with a rule that says if this word comes later than that one, forbid it. That is an if statement. Typeset in symbols it looks like a law of nature; strip the costume off and it is the conditional from the linked list — a special case bolted on because the data structure doesn't natively have the property we need.

And it is not free. Every word is compared against every other word, so doubling the length of the text quadruples the work. That is why long context is a product you pay extra for, and why a meaningful share of the gigawatt clusters exists to make that ballooning comparison run fast.

Now watch him remove the if.

Suppose that instead of comparing everything to everything and then crossing out the future, you carry a running summary — a single state that starts empty and is updated once per word, in order. Word one folds in, then word two. When the model reaches word five it consults the summary, which holds words one through four and nothing else.

There is no crossing-out, no forbidden half, no rule to enforce and nothing to enforce it against, because word five cannot see word twelve — word twelve has not been added yet. The future simply hasn't happened. Causality stopped being a rule and became a property of the shape of the thing.

And the cost collapses with it. Double the document, double the work — not quadruple. The most expensive property of the architecture goes away, and not because of a faster chip. It goes away because somebody changed the data structure.

Is any of this new? No, and the kid will tell you so before you can ask. The running summary is older than the transformer: Jürgen Schmidhuber published it in 1992 as a scheme for programming fast weights, a quarter of a century before attention existed, and a 2021 paper proved the two are formally the same idea in different notation. Softmax attention is not the original design. It is the deviation.

Nor is it unbuilt, which is the part he finds funny. Go back to the model cards from the last chapter and read the architectures instead of the licences. MiniMax interleaves seven linear layers with every softmax one; Qwen runs three gated-recurrent blocks for every block of attention; Kimi ships a linear variant. The labs that gave away their weights under MIT are the same labs that quietly stopped building the grid.

So what he is claiming is only the observation: that a running summary is the same shape as a Git commit chain and as the pointer-to-a-pointer, a thing whose current value is the complete account of everything before it. That the elegant version sat in a 1992 paper the entire time. That the whole edifice is the textbook linked list, scaled to a national power grid, with an if at the top most people have agreed to stop seeing.

And then the part nobody puts in a keynote: it does not work for free.

A summary is a compression, and compression loses. There are theorems about this — to reproduce a distant passage reliably, the state must grow with the length of what you are reproducing, the one concession a fixed-size summary will not make. Ask it to reach back forty thousand words for one exact number and it fails where the grid does not. Which is why almost nobody ships the pure form. They ship hybrids: mostly running summary, with a few honest full-attention layers left in to do the remembering. The branch is deleted from seven layers out of eight and kept in the eighth, on purpose, because somebody has to hold the receipts.

"They optimized the branch," he says, in a voice with no triumph in it at all. "You're supposed to delete it — and then find out what it was holding up."

VII. Why He Is Not Going to Train GPT-6

The moat, drawn to scale: every operating and proposed US data centre, plotted against the transmission grid that has to feed it. (NREL, 2025.)

Let us be extremely clear about what this twenty-year-old cannot do, because the fantasy version of this story is a lie and the true version is more interesting.

He cannot train a frontier model. Not close, not with a miracle, not with a year of nights.

The arithmetic of a training run is brutally simple in shape: cost scales with how big the model is, multiplied by how much text you push through it. Both numbers are now astronomical. A frontier system in 2026 means tens of thousands of the best accelerators money can buy, running flat out for months, drawing enough power to need its own substation and — increasingly, and not as a metaphor — its own reactor. The bill lands somewhere between nine and ten figures. It is the kind of number that no longer belongs to the software industry at all; it belongs to the same category as a bridge, a port, a launch vehicle.

He has two used graphics cards and roughly €600 of student loan, and one of the cards has a fan that makes a noise like a wasp in a jar.

So he is not attacking size. This is the strategic insight, and it is the same one that made Linux work: the original Torvalds did not try to out-engineer Sun Microsystems. He wrote the kernel, gave it away, and let the world assemble the rest around it. The moat was never the operating system's features. The moat was the vendor's capital, and capital cannot defend against something that is free and improves every Tuesday.

So the kid attacks the layer above the model and the layer below it. He attacks orchestration.

His framework — he has not named it publicly yet, and the working directory on his machine is called, with the total lack of imagination that characterizes people who are actually building things, ml/ — does three things.

One: it trains across whatever hardware happens to exist. Not a cluster — a network of volunteers, each with an ordinary gaming machine, each training on their own slice of text and contributing what they learn back to a shared model. The idea is decades old and it works fine on paper. In practice it is murdered by one thing: the internet is too slow.

A moderately sized model is about fourteen gigabytes of numbers. Sending all of that to every volunteer, and all of their corrections back, on every single step of training, over a Finnish home broadband connection, is not a training run. It is a lifestyle.

So he cheats, in the way good engineers cheat. On each step, a volunteer's machine sends back only the largest corrections — roughly one in a thousand, the ones that actually move something — and quietly remembers all the ones it held back. Those held-back corrections don't vanish; they accumulate locally and get folded into the next message, and the one after that. Nothing is lost. Everything is merely late. The traffic drops by a factor of a thousand, and — this is the part that startles people the first time they see it — the model learns almost as well as if you had sent everything.

Two: it is OSAID-compliant from the first commit, on purpose, as a design constraint rather than a compliance exercise. Every byte of the initial corpus has a documented provenance record. The filtering pipeline is a versioned, deterministic script that any stranger can rerun to reproduce his exact dataset from public sources, byte for byte, hash for hash — content-addressed, of course; he is his ancestor's child in this if nothing else.

Three — and this is the part that made a research director at a Seattle nonprofit sit up very straight when she saw it — it is modular where the data is unshareable. The architecture explicitly supports plugging in local, private, legally immovable corpora as fine-tuning inputs that never leave the building. A Finnish regional hospital can specialize the base model on patient records that cannot lawfully be copied, on its own hardware, under its own roof, and publish the description of that data — scope, characteristics, collection method — exactly as the OSAID's fourth data class requires. The weights improve. The records never move. Nobody signs a data processing agreement with a company in California.

That last one is not a technical feature. It is a geopolitical feature that happens to be implemented in Python.

VIII. The Interlude in Which a Venture Capitalist Is Not Worried

"There's no distribution story."

I described this project — in the abstract, without a name, as a hypothetical — to a partner at a growth fund with roughly $4 billion under management, over coffee that cost $7.50 and arrived in a glass. This is early afternoon in Palo Alto, where almost every other person in the Cafe was hacking away in Claude Code with 10 terminal windows open on the MacBook Pro's luminous screen.

He was not worried. He was generous about not being worried, which is a specific and identifiable tone in venture capital, the tone of a man explaining why a small animal cannot hurt him.

"Sure," he said. "There's always a kid. There's a kid every month." He turned his cup a quarter rotation. "Look, the infrastructure spend is the moat. You're talking about, what, a hundred billion in capex just this cycle? Nobody catches that from a dorm. And even if the architecture is more efficient — and I'd want to see the evals, the evals are where these things die — you've got no distribution, no enterprise sales motion, no compliance story, no SOC 2, no support contract. Fortune 500 CTOs don't deploy a GitHub repo."

Every clause of that is true. Every single one. It is also, verbatim, allowing for the substitution of proper nouns, what Sun Microsystems, Digital Equipment Corporation, SCO, and Microsoft said about Linux between 1994 and 2001, and I did not point this out, because there is no polite way to point it out, and because he would have had an answer, and because the answer would also have been true.

The thing about capital moats is that they are perfectly effective against competitors and completely useless against commoditization. Nobody beat proprietary Unix by building a better proprietary Unix. Linux beat proprietary Unix by making the category worthless — by turning "operating system" from a product line into a substrate, a thing you no longer buy because it is simply there, like a road. The vendors did not lose a fight. They woke up one morning and discovered that the thing they sold had become plumbing, and that IBM was now in the consulting business.

The open source movement does not win arguments. It waits, and then the argument is no longer relevant.

IX. What Is Actually at Stake, Stated Without Adjectives

Every connection labelled, every label somebody's decision. Infrastructure is a synonym for "who you have to ask."

Strip the romance out and the argument is about ownership of an infrastructure layer.

If machine intelligence is genuinely the next foundational substrate — electricity, the highway system, TCP/IP — then the question of who owns it is not a technology question. It is a constitutional one, and it has already been decided in a few places while everyone was reading benchmark scores.

Proprietary models create cognitive monopolies. Not metaphorically. Structurally. Lock the parameters and the corpus behind a metered endpoint and every developer on earth becomes a tenant — exposed to price changes they cannot forecast, deprecations they cannot appeal, capability regressions they cannot detect, and biases they cannot audit because they cannot see. That is not a market relationship. That is a landlord relationship with an API key.

Against that, the OSI's word for the alternative is polyculture — deliberately borrowed from agriculture, where the monoculture failure mode is well documented and involves famine. A polyculture of models can be audited for safety and bias by independent researchers worldwide. It can be specialized for languages and cultures that no Silicon Valley product manager will ever build a business case for. It fails locally instead of globally, which is the single most underrated property any infrastructure can have.

And the economics run the same direction. The technology analyst Jon Hansen has argued that extracting real value from AI in complex enterprise environments — global supply chain procurement is his example — depends on agent-based modeling rather than classical equation-based macro models. An equation-based model generalizes from the top down: it assumes the system's behavior and solves for the parameters. An agent-based model builds from the bottom up: thousands of autonomous actors, each with local rules and local information, interacting until system-wide behavior emerges that nobody wrote down.

To build one you need models you can inspect, fine-tune, replicate cheaply, and run entirely inside your own network — because the data those agents reason over is your pricing, your suppliers, your margins, your contracts. A metered API cannot do this without you shipping the crown jewels to a third party's server and hoping. Open weights do not just make agent-based modeling cheaper. They make it legal in industries where the alternative is a compliance violation.

Which is the same argument, one abstraction layer up, as the hospital that cannot copy its records: openness is not a preference here. It is the only configuration in which certain entire categories of work are permitted to exist at all.

The industry stands where the server market stood in 1998, and the shape of the resolution is already visible to anyone willing to look at the shape of the last one.

X. August 25, 2026

Helsinki, over the water. Thirty-five years to the day.

The week before, a dominant AI provider changed a rate limit without notice.

That is the entire event. A number in a configuration file went from one value to a smaller value, deployed on a Tuesday, announced on a status page nine hours later in the passive voice. And across the world, thousands of downstream applications — a logistics dashboard in Rotterdam, a triage assistant in a clinic outside Nairobi, a homework tutor with 40,000 students, a bank's fraud pipeline — began returning 429s and then, in the way of all systems built on a single dependency, began failing in ways their authors had never tested because it had never occurred to them that they might need to.

The forums went the way forums go. Rage. Threads. Screenshots of the status page. A senior engineer somewhere posted the sentence that got quoted for a week: "We didn't build a product. We built a very expensive opinion about somebody else's uptime."

The kid read all of it, in the blue light, at his desk, with the fan going. And then he did the arithmetic that had been sitting at the back of his skull for two years — the arithmetic of the date — and he understood that if he did not post it this week, the coincidence would be gone forever, and coincidences are the only free marketing an unfunded person will ever receive.

He wrote it in a plain text editor. No formatting. He wrote it in about eleven minutes and then edited it for two hours, mostly to remove things that sounded impressive. On the morning of August 25, 2026 — thirty-five years to the day since a message went out to comp.os.minix — he posted it to a decentralized developer forum:

Hello everybody out there using proprietary AI APIs —

I'm doing a (free) open-source foundation model architecture and distributed training orchestrator (just a hobby, won't be massive and professional like GPT-6 or Claude) for consumer-grade GPU clusters. This has been brewing since April, and is starting to get ready. I'd like any feedback on things people like/dislike in the current open-weights ecosystems, as my framework resembles them somewhat (same general attention mechanisms, due to practical reasons).

I've currently ported a fully OSI-compliant data ingestion pipeline and a highly optimized local inference engine, and things seem to work. This implies that I'll get something practical within a few months, and I'd like to know what architectural features most people would want. Any suggestions are welcome, but I won't promise I'll implement them :-)

PS. Yes — it's completely free of any proprietary training data or restricted RAIL licenses, and it supports distributed multi-node parameter sharing. It currently requires a basic understanding of PyTorch to set up, so for those hoping for an alternative to a polished, corporate API wrapper, please ignore me. It is currently meant for hackers interested in neural architectures and actual open source.

Read it beside the 1991 original and the effect is uncanny, almost embarrassing, like watching someone try on a dead relative's coat and discovering it fits.

The same apology. The same just a hobby. The same preemptive deflation — won't be massive and professional — deployed against a competitor with a market capitalization larger than most national economies, which is either the most Finnish sentence ever constructed or the single most effective piece of positioning in the history of technology, and is probably both. The same acknowledgment of what he borrowed and why (same general attention mechanisms, due to practical reasons). The same solicitation of feedback with the same cheerful refusal to be bound by it. The same postscript that tells you exactly who this is for and, more importantly, exactly who it is not for — please ignore me — which is not modesty. It is a filter. It is the most efficient recruiting instrument ever written, because the only people who read please ignore me and keep reading are precisely the people you want.

He posted it and then he did what his namesake did, which was close the laptop and go and have breakfast, because there was nothing else to do, and because the entire theory of this thing is that you cannot make it happen, you can only make it possible.

Fourteen hours later there were nine replies. Three were jokes about his name. Two were requests for a Windows binary. One was a physics postdoc in Zagreb, asking, with an urgency that came through even in ASCII, whether the federated gradient compression would tolerate nodes that drop off the network for six hours at a stretch, because that is what her university's power situation actually looks like and every existing framework assumes it does not.

He wrote back within the hour. Yes. That case had been in the design from the start, because that case was the design — the residual accumulates locally and folds back whenever you return, and a node that vanishes for six hours is not an error condition to be handled. It is just a node with a longer delay.

No special case.

XI. Coda: The Word for What He Actually Has

Somebody's room, still on. 4:51 a.m., and the fan is still running.

The story is called Linus Torvalds Has a Hallucination, and by now you know the double meaning was never subtle, so let us finish the job.

The first hallucination belonged to the machine: torch.distributed.all_reduce_sparse_hybrid, a function assembled out of plausibility, delivered with perfect confidence, wrong. That kind of hallucination is a defect. It is being engineered against, in labs, at enormous cost, with real progress, and it will be substantially solved and it will not matter, because it was never the interesting one.

The second belongs to the kid, and it is the load-bearing one. He walks around a world in which four or five corporations control the means of cognitive production, in which the capital requirements are measured in reactors, in which the analysts and the founders and the perfectly reasonable venture capitalist with the $7.50 coffee all agree that this shape is now permanent — and he sees, with total clarity, a thing that does not exist yet. An architecture with no branch in it. A network of ordinary machines in ordinary rooms, training a model together. A hospital in Kuopio that improves an open model on records it never has to hand over. A world where the substrate is just there, like a road, and no one has to ask.

None of it is real. He can describe it in complete sentences, in specifications, with correct indentation. Every word is a forward-looking statement about a thing that has not happened.

Which is precisely, exactly, atom-for-atom what a twenty-one-year-old was doing in this same city in August 1991 when he apologized in advance for a hobby project that would not be big and professional like GNU, and which now boots inside every machine used to train every model that hallucinates functions at three in the morning.

There is no reliable way to tell the two hallucinations apart in advance. Both are confident. Both are well-formatted. Both describe something that is not there. The only difference — and this is the entire, unglamorous, deeply unsatisfying moral of thirty-five years of open source — is that one of them is checkable, by anyone, at any time, forever, because the source is right there and you may run it yourself and see.

Given enough eyeballs, all bugs are shallow.

Given enough eyeballs, so are all the walls.

The fan is still running. Somewhere in Zagreb, a node comes back online, and its residual folds quietly into the sum.

Works Cited

1. Linux History — The Living Internet. https://www.livinginternet.com/i/iw_unix_gnulinux.htm
2. What We Know For Sure on Linux's 20th Anniversary — The Linux Foundation. https://www.linuxfoundation.org/blog/blog/what-we-know-for-sure-on-linuxs-20th-anniversary
3. History of Linux — Wikipedia. https://en.wikipedia.org/wiki/History_of_Linux
4. Linus Torvalds' original announcement on Usenet — Learn Linux. https://www.learnlinux.ie/content/linus-torvalds-original-announcement-usenet
5. Re: What would you like to see most in minix? — comp.os.minix, Google Groups. https://groups.google.com/g/comp.os.minix/c/dlNtH7RRrGA
6. "I'm Doing an Operating System, Just a Hobby, Won't Be Big and Professional" — Cadence, Breakfast Bytes. https://community.cadence.com/cadence_blogs_8/b/breakfast-bytes/posts/i-m-doing-an-operating-system-just-a-hobby-won-t-be-big-and-professional
7. An illustration of good taste in code — Felipe Contreras. https://felipec.github.io/good-taste/parts/1.html
8. Engineering Philosophy: Linus Torvalds, The Special Case That Wasn't — Blake Crosley. https://blakecrosley.com/blog/engineering-philosophy-linus-torvalds
9. Linus Torvalds' linked list argument for good taste, explained — GitHub / mkirchner. https://github.com/mkirchner/linked-list-good-taste
10. OSAID FAQs — Open Source Initiative. https://opensource.org/ai/faq
11. The Open Source AI Definition 1.0 — Open Source Initiative. https://opensource.org/ai/open-source-ai-definition
12. Open Source AI — Open Source Initiative. https://opensource.org/ai
13. Part 1 — Open Source AI Models: How Open Are They Really? — Hunton. https://www.hunton.com/insights/publications/part-1-open-source-ai-models-how-open-are-they-really
14. Open Source Artificial Intelligence Definition 1.0 — A "take it or leave it" approach — Wolters Kluwer Copyright Blog. https://legalblogs.wolterskluwer.com/copyright-blog/open-source-artificial-intelligence-definition-10-a-take-it-or-leave-it-approach-for-open-source-ai-systems/
15. What Is Open Source AI? A Practical 2026 Guide to OSAID — Moesif. https://www.moesif.com/blog/technical/api-development/Open-Source-AI/
16. The Open Source AI Definition is a step forward in defining openness in AI — Open Future. https://openfuture.eu/blog/the-open-source-ai-definition-is-a-step-forward-in-defining-openness-in-ai/
17. DeepSeek-V4-Pro-0813 model card (weights under the MIT Licence; no training-corpus documentation) — Hugging Face. https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro-0813
18. Qwen3.8-27B model card (Apache-2.0) — Hugging Face. https://huggingface.co/Qwen/Qwen3.8-27B
19. Qwen3.8-2.4T-A95B model card (custom qwen3.8-max licence on the flagship tier) — Hugging Face. https://huggingface.co/Qwen/Qwen3.8-2.4T-A95B
20. Kimi-K3 model card (custom "Kimi K3 Licence") — Moonshot AI via Hugging Face. https://huggingface.co/moonshotai/Kimi-K3
21. GLM-5.3 model card (custom glm-5.3 licence) — Z.ai via Hugging Face. https://huggingface.co/zai-org/GLM-5.3
22. Transformers are RNNs: Fast Autoregressive Transformers with Linear Attention — Katharopoulos, Vyas, Pappas & Fleuret, ICML 2020. https://arxiv.org/abs/2006.16236
23. Linear Transformers Are Secretly Fast Weight Programmers — Schlag, Irie & Schmidhuber, ICML 2021 (formal equivalence to Schmidhuber's 1992 fast-weight memories). https://arxiv.org/abs/2102.11174
24. Simple linear attention language models balance the recall-throughput tradeoff — Arora et al., ICML 2024. https://arxiv.org/abs/2402.18668
25. MiniMax-01: Scaling Foundation Models with Lightning Attention — MiniMax technical report. https://filecdn.minimax.chat/_Arxiv_MiniMax_01_Report.pdf

Image Credits

All images are reproduced from Wikimedia Commons under the licences shown, resized to a maximum of 1600 px on the long axis. Attribution is required for the CC BY and CC BY-SA entries.

CC0 = public-domain dedication, no attribution required. CC BY 2.0 / CC BY-SA 2.0 / CC BY-SA 3.0 require credit and, for SA terms, share-alike on adaptations. Full licence texts: https://creativecommons.org/licenses/