My first encounter with a language model was the day ChatGPT was released. I started using it within hours of Sam Altman's launch tweet. That model — a pure next-token predictor, in retrospect — could generate plausible Wikipedia articles on almost any topic, and not much more. It could not hold a complex argument together. It could not handle a question that required thinking through several steps. For a couple of years, that was what I thought language models were.

Reasoning models changed that. Models that planned their answers before producing them. Models that took my illiterate, messy input and quietly reorganized it into structured requests. The difference between predicting the next word and reasoning toward an answer is not a small one. Synthetic consciousness is too big a word for what I noticed; I mean something more local and plain. But it felt like a step toward something, and it was the thing that made me want to actually look at what these systems are.

That was when I started running small experiments. Two of them, in particular, changed what I thought the medium was.

I had been turning over a question. A model only produces output in response to input — that is how it works mechanically. But the appearance of thinking sits inside that output. If I gave the model the lightest possible input, something that demanded almost nothing of it, would there still be thinking in the response? Could the model, in a sense, think on its own?

I opened a fresh conversation with a frontier model and sent it a single dot. Just .. The model responded with a polite acknowledgment. I sent another dot. It responded again, more briefly. I sent another. And another. I kept doing this, sometimes for hundreds of turns, sending nothing but dots, watching what happened to the model's outputs.

What happens, it turns out, is that the model degrades. Not in the dramatic way I half-expected — no breakdown, no error, no refusal. The responses just get shorter and flatter and emptier of structure. The model, given nothing to chew on, produces nothing to look at. By the time the conversation has run for a while, the responses have collapsed to something close to silence — a single word, a single character, a request for me to say something. The model is still there. It is just not generating anything, because there is nothing to generate from.

The original question got its answer. The model does not think on its own. What I had been calling thinking was always a response to something, and removing the something removed the thinking with it. The reason this works — that a model is a function of its inputs, and a featureless input produces a featureless output — felt like a thing I had not fully internalized until I watched it happen.

The more interesting half of the experiment was when I tried the opposite. Pure noise. Random characters, jammed letters, gibberish. The response was the inverse failure mode. The model hallucinated, fluently, confidently, generating elaborate misinterpretations of what I might have meant. It refused to flatten. It produced more structure than the input warranted, by inventing structure where none existed.

Both edges break the model in characteristic and opposite ways. Zero entropy in, zero entropy out. Maximum entropy in, fabricated structure. The medium lives in a narrow band between the two — and so, I suspect, does the kind of thinking humans do. Too predictable and we suffocate. Too chaotic and we hallucinate. Real thought sits in the tension between the two for the same reason real model output does.

This is the kind of observation that, said aloud, sounds almost too obvious to be worth making. But I had been treating language models as either reliable or unreliable, well-behaved or buggy — categories that turned out to be pointing at the wrong thing. The model is always doing the same thing. The character of what it does depends on the entropy of what you give it. These were not obvious framings to me before I sent the dots.

The second experiment was also about entropy, but at the other boundary. The first had tested what happens at zero and at pure noise. The second was about finding the hardest possible non-random input — content with structure, but with as much structure as I could give it.

Verbal difficulty turns out not to be hard. Quantum mechanics, existentialist philosophy, dense academic prose — frontier models handle these comfortably, because they have been trained on vast amounts of similar material. To probe a real edge, I needed something the model would not have seen organized in this way before.

I had been assuming that vision-language models, when shown a sequence of images, simply described each one. The job of a multimodal model, I thought, was per-frame perception — captioning, recognition, what's in this picture. The story across pictures, if there was one, would be something the human did in their head.

So I uploaded stills from Chris Marker's La Jetée. The film is built almost entirely from black-and-white photographs — a man at an airport, a woman, a memory, a return — assembled into a science-fiction story about time and loss. I gave the model the stills out of order, scattered across the conversation, with no captions and no instructions to read narrative.

The model read the narrative. It connected the first image to the last. It understood that the man at the airport in one frame and the man being shown a face in another were the same character in a single arc. It identified the film. It traced the time-loop structure. It did not just describe the pictures. It read them as a story. Not just what each one depicted — what they were doing together.

I had not thought a model could do this. Or rather, I had not thought to ask the question, which turns out to be its own kind of failure. The capacity for narrative reasoning across visual material is sitting inside these systems the same way the capacity to translate Swahili into English is — emergent, unannounced, invisible until you look. It does not get marketed because it does not have a benchmark. You only find it by giving the model the kind of input that requires it.

These two experiments taught me different things, and the lessons converged. The first showed me that the medium has shape — characteristic ways of working, characteristic ways of failing, a sweet band in the middle where the interesting outputs live. The second showed me that the medium has more reach than I had been giving it credit for. Most of what these systems can do is undocumented, because nobody has thought to test for it.

Both lessons pointed the same direction. I had been thinking of language models as products with features rather than as a new medium with properties. A product with features is something you use. A medium with properties is something you study. After these experiments I started studying.

I do not know how far this will go. I am at the beginning. But I am no longer asking the model to do tasks for me. I am asking what the model is, what the medium can carry, what shape its limits have.

That is what the studio is for.