Edit Meaning, Not Tokens: Linus Lee on Latent-Space Interfaces

Nathan Labenz has followed Linus Lee's work for years, from latent-space interfaces that visualize generative models to techniques for semantically editing text and images. He introduces Lee as an AI product leader at Notion and a one-of-a-kind tinkerer, then asks him to start with the interfaces themselves. Lee's longest-running direction is to control generative models in their latent space rather than in the input space people already know.

The usual way to make an image, he says, is to describe it in words—a cow in a grassy field, sunlight, a long shot, 35mm film—and hope the model complies. Another way is to start from an image you already like, find a second image whose lighting, framing, or character you want, and ask the model to merge those attributes in semantic space rather than in pixel space. Several of his demos do exactly that inside CLIP: start with a face and add a vector that makes it smile, or start with a photograph and add a style by adding vectors in the model's latent space.

The same trick works on text. Lee trained a model that can embed a sentence and invert the embedding back into words with little loss of meaning, which lets him combine two sentences semantically or interpolate between an optimistic line and a mellow one. A later prototype puts those sentences on an infinite canvas. One hand chooses an attribute to control—sentiment, fancy versus simple English, topic—while the other drags a sentence; the farther you pull, the stronger that attribute becomes, and the trail of pulls becomes a branching edit history.

Most of the research prototypes, he admits, are not yet useful. The latent-canvas edits are crude, and the models are too small for precise control. The ones that did become daily tools were simpler: an Obsidian- or Roam-style outliner that auto-linked entities in a graph, built mostly with dumber techniques than language models. The eventual goal is always utility, but any given prototype may only be a way to find the next problem.

Labenz compares the canvas demos to Xerox PARC: after trying Apple's Vision Pro, he could imagine using the brain's spatial intuition for more than parking a YouTube window next to email. Lee has spent years rewriting the motivation for these "weird spatial demos." The closest metaphor he has found is the spectrogram. Raw sound is a waveform, a single vibration over time. People who work with audio professionally almost never stay there. They look at frequencies over time, where repeating patterns, bass, and tone shifts become visible, and they edit in that projected space—cutting the lows, adding reverb only to the voice range—rather than pushing on the wave itself.

That is the interface he wants for language: a tool that lets you edit text or work through ideas not in words, characters, and tokens, but in features. Features might be as nameable as "is this a question" or "is this about computers versus plants," or as unnamed as the properties language models already track without anyone having a word for them. Spectrograms work because humans already understand color, range, and position in space. Once ideas can be projected that way, he wants people to bring proprioception, scale, and distance into how they think, not just eyeballs and pixels.

Labenz points to Riffusion, which fine-tuned Stable Diffusion on spectrogram images and then converted those images back into music, as a preview of how representation spaces can be bridged. Lee notes that speech and music models already often operate in frequency space; Riffusion adds a second jump by using a convolutional image architecture to generate something that represents audio, and it still works. The broader lesson he draws is that if you have data, compute, and an architecture that is not a hard bottleneck, a surprising fraction of wild ideas now work within an order of magnitude of efficiency. Open-source training infrastructure has moved from a few GPUs for a few days to thousands of GPUs for weeks, and the result is an explosion of models that work across modalities.

Labenz has a hunch that he first saw several now-canonical interpretability results in Lee's small-model experiments: representation engineering from Dan Hendrycks and collaborators, and Anthropic's work toward monosemanticity. Lee does not come from academia. His technical background is product engineering and web apps, "the furthest thing you can be from training models," so he had to step slowly into the research community and watch how ideas move through it.

His old mental model was the textbook one: researchers invent, papers appear, industry picks the ideas up, and smaller groups follow. In machine learning, with tools this accessible, the picture is more nuanced. At any moment a large group of people already know most of what can be done with current models—some in industry, some in academia, some tinkering after a day job. The next ideas are mostly a function of what is already known, so different people stumble on the same techniques at the same time.

The intuition that language models have a linearized feature space you can edit in was, he thinks, already in the air. He proved it out the way he enjoys most, by building interactive web prototypes. Other people took longer to make the same idea theoretically robust and write it up. The ideas were not different so much as spoken in different dialects, reaching different parts of the community on different clocks.

Labenz presses on the practical problem: once you leave the embedding lookup table and go deeper into a network, how do you even know which direction is "smile"? Lee's favorite model of research is the path he actually walked. Academic papers were hard to read at first, so he downloaded GPT-2 from the Hugging Face Transformers repository, got a minimal version generating text, and treated it as a live organism he could understand because he already knew Python. He put print statements everywhere and did what he calls a model autopsy.

For a while, every problem still had a search result: a Hugging Face forum post, then a GitHub issue, then a three-month-old paper with two citations and a one-star reproduction that might be broken. At that wall you are at the frontier. He still had things he wanted to do, so he read papers, combined pieces, and tried approaches with no consensus behind them. That is how he built the autoencoder that moves fluidly between text and embeddings, and how he is now adapting mechanistic interpretability techniques—mostly developed on ordinary GPT-style language models—to embedding spaces.

A lot of that work, he says, still looks like finding a weird three-star GitHub repository in the morning, transplanting it, and hoping the implementation is not wrong. The method is not glamorous. It is the same stubborn debugging loop a product engineer already knows, pointed at models instead of web apps.

Asked what is going on inside a Transformer, Lee starts with humans. The default story is that we think, draw conclusions, then act. He does not believe that. He thinks the brain and body take actions first, then retroactively build a narrative for why—an account that may be what people call consciousness. On the model side he splits the problem in two: how a Transformer processes information in a single forward pass, and how we sample from the distribution it outputs.

A language model is a statistical model of the probability of every possible continuation. If compute were free, you would score every branch and pick the best. Instead we sample. The common method commits one token at a time from the top of the distribution; beam search keeps a buffer of branches; other tricks warp the distribution to reduce repetition or amplify the gap between a small model and a large one, as if approximating an even smarter model. Sampling is how you hunt through a cloud of continuations. Getting that cloud in the first place is the forward pass.

Lee's picture of the forward pass, which he credits in part to write-ups from Anthropic, is a stack of mini-networks, one per token. Information flows down a main artery. Every so often the model branches off, does a little computation, and merges the change back. Small models might have 12 to 24 of those branch-and-merge blocks per token; very large ones can have around 100. After each merge, the token-level streams broadcast what they contain and what they are looking for, fetch from one another, and continue. Labenz supplies the standard names: the artery is the residual stream, attention is how the streams exchange information, and the MLP layers do much of the actual association. Meaning is often smeared across several blocks rather than implemented as a clean Paris-to-Eiffel-Tower lookup.

Most of the time Lee works in PyTorch on a GPU Linux box. JAX and TensorFlow are the usual alternatives; he sees TensorFlow in maintenance mode and JAX as a compiler-like way to describe a model as a function you then compile. PyTorch lets you hold a tensor, look at the numbers, and apply operations the way ordinary programs are written. That concreteness matters for interpretability: you want to peek at a value anywhere in the network and ask what happens if you tweak it. Researchers outside Google mostly use PyTorch for that reason; interpretability work skews even harder toward it.

He visualizes more than he would if the tools made it easier, and the views that help with autoregressive Transformers are not the same as the views that help with embeddings. Visualization is something he is relatively good at, so he can whip up a React explorer faster than he can invent a new training trick. Early in a field, he argues, the quality of the tools bottlenecks the quality of the research. Hugging Face Transformers is built to host a huge range of models, which makes a simple question—what vector operations happen at this block?—almost impossible to answer through the thicket of conditionals. He defaults to smaller tools that fit his use case, then consolidates repeated ones into a personal library.

When he opens a new folder in his personal monorepo, a handful of UI components, eval runners, and training helpers come along by default. One lesson from moving into research is not to feel guilty about copy-paste. You do not yet know how the thing will change, and over-generalizing a library too early is its own trap. The reusable pieces tend to be ones he grew himself, not an off-the-shelf "interpretability framework" he had to learn.

When Lee started, GPT-J was the largest open-source model around. Parts of his stack have since moved to Llama 2, but GPT-2 remains a favorite: trained before the internet filled with model-generated text, well documented, "the fruit fly of the language model world." More theoretical interpretability groups have moved to Pythia, which is trained with many checkpoints so you can watch features evolve. Because he works so often with embeddings, he uses open-source embedding models and a custom T5-based model he trained to reconstruct text from embeddings. T5 is no longer cutting-edge, but it is still a rock-solid medium-sized model to fine-tune, and he has already built the scripts and datasets around it.

Sitting down to work now feels like a sprawling workshop: tools and ingredients at arm's length. Pulling in a new model would mean redoing a lot of that. Labenz asks how exportable the cockpit is. Lee's metaphor is a watchmaker's bench. You would not expect to drop into an expert's workshop and immediately get to work; you would have to learn the layout or rearrange it. Concretely, he has a local GPU rig on his desk plus machines in the cloud, a specific folder layout, datasets that scripts assume live in those places, and trained models that upload to S3. Isolated pieces—a mini library for running many GPT-4 inferences in parallel—could be shared. The spider web of where things live is much harder to open-source, and some of it sits under Notion.

He uses language models while coding, but not more than most people with Copilot and ChatGPT. GitHub Copilot, and sometimes Sourcegraph Cody, are good for boilerplate he already intended to write. They are not good for the complex matrix algebra where dimensions are arbitrary and he cannot tell if the suggestion is correct. For those cases he works it out on paper or pastes sample code into GPT-4 and asks it to find the bug. Final verification is still running the code and printing intermediates, which is another reason he prefers PyTorch to more opaque stacks.

Anthropic trains frontier models in part because it believes interpretability on smaller systems will miss qualitative jumps. Lee splits what we can know into two buckets. The first is the physics of neural nets under a given objective—claims like the linear feature hypothesis, that facts show up as directions in vector space. If you can prove that and see it in small models, you can reasonably guess it will hold at scale; most of his work sits there. The second is what a specific model knows: which features, how large the circuits, whether they are about topics or grammar. Vision models already hint that interpretability has a sweet spot. Tiny models learn uninterpretable features; mid-sized ones grow cat ears and car wheels; still larger ones may think in higher-level features humans do not have words for.

On reasoning, he refuses the stochastic-parrot binary. He asks three nested questions. One: if you were omniscient and could set every weight, could some Transformer do the task? Two: could a randomly initialized net reach those weights by gradient descent? Three: will a real training run, with limited-precision floats on internet-scale data, land close enough to that ideal? For most definitions of reasoning, he thinks the answer to the first is almost always yes, and his non-rigorous intuition is that the second is yes in the infinite-compute limit. Small Transformers can be trained on enough math examples that you can look inside and see the correct algorithm.

The live question is whether we have enough data for huge models to move from memorization to something we would call full reasoning. Relative to parameter counts, current datasets are small, so models can memorize and still look strong. Showing that a large model solved a problem by an internal circuit rather than pattern matching is hard when the problem distribution is so diverse. Getting to demonstrable generalization, he thinks, would take extremely clean data that does the correct thing for long enough that the model can afford to forget memorized solutions. Labenz brings up Tiny Stories, where a reduced vocabulary let simple reasoning, including negation, appear at around 30 million parameters. Lee's related suspicion, looking at OpenAI's video model, is that early training may include large amounts of game-engine physics—another bet on synthetic data. Models are lazy: they learn what you wanted only after every cheaper option is exhausted. Natural internet math is full of wrong proofs, so the model also has to learn which continuations are likely garbage.

As a product lead bringing frontier models to Notion's users, Lee keeps a short list of asks for model labs, because they always ask. He wants models that hallucinate less, that are cheaper and faster, and that follow long, complex instructions more faithfully. General reasoning is a fourth item, important and much harder. Claude 2 and GPT-4 already showed marked gains on the first three, even though they cost more, and those gains unlocked new products.

Notion Q&A answers questions from a company's knowledge base. That needs the model not to hallucinate from its own memory or from documents in context, and it needs the model to follow what Lee calls massive books of instructions: dozens of bullets on how to format an answer, what to do and not do, and how to handle this situation versus that one. Earlier models struggled with instruction blocks a thousand, two thousand, even five thousand tokens long. AI Autofill is the other example: a language-model call used like an Excel formula, filling a column across a database of interviews, companies, or customers. Some customers have tens of thousands of rows. Doing that means sending OpenAI or Anthropic thousands of requests in a few minutes, which is a latency and cost problem as much as a smartness problem.

Labenz puts general capability first on his personal list and wonders why Lee does not, given that a model which wrote as the user would seem worth hundreds of dollars a month. Part of the reason, Lee says, is tractability. If you tell Google you want better reasoning, the engineers will ask what to measure. Instruction-following and hallucination are facets of reasoning you can move in months to a year, and they unblock current products. Another part is packaging. Chat makes you wait on a single token stream; Autofill is a batch job. Someone might upload a 2,000-row CSV, fill five columns, and want the table back in seconds so they can filter it. At billions of tokens generated per day, smaller startups can ship experiences Notion cannot afford. He also jokes that most business and academic documents are interpolations of documents already written. He puts that figure at something like 95 percent of what people write inside Notion, not because nothing is novel, but because most instances of communicating well already live in the training set. For those, steering beats inventing.

Labenz's theory is that the AI app industry has been building scaffolding to compensate for model weaknesses—grounding against hallucination, reranking because context was small—and that a model like Gemini 1.5, with a million tokens of context and striking recall demos, might make some of that scaffolding unnecessary. Lee is curious what use cases motivated that window. His hunch is multimodal: a long piece of audio or video filling the context. In pure text, he still sees benefits to retrieving a limited set of documents rather than stuffing everything in.

Observability is the first. If you give a model 10,000 inputs and it is wrong, debugging is an interpretability problem of its own. A pipeline that retrieves a top ten lets you ask whether the answer was in the documents, whether it sat at the beginning or the end, and what happens if you swap one out. Pipelines also help with cost and latency for a given compute budget, and they let you upgrade the language model and the retriever independently. Needle-in-a-haystack tests, he argues, do not match the retrieval Notion actually needs. Documents may be out of date, written by someone who is not authoritative, or in another language that conflicts with a canonical HR page. The model has to reason over those cases using Notion's instructions. A question like "has the AI team been productive this week?" is multi-step synthesis, not a lookup. The hardest retrieval failures are those edge cases, and they are much easier to inspect when you have ten examples rather than ten thousand.

He does not think context length is the most dire need for that product, even if it could be a game-changer for audio. Training a model for such long windows, he notes, probably took architectural invention, engineering, and scarce long documents, so Google must have had a serious internal use case. Labenz adds agents as another candidate: appending past failures and rolling forward, even if even ten million tokens will eventually run out.

Asked for tips he does not see developers use enough, Lee offers two boring ones. Spend time with data—not just eval charts, but a table of a hundred inputs and outputs. Ask what you would have written, walk through the steps, and study the edge cases where the model fails. He has even found it interesting, if a little dubious in value, to read raw pretraining text from The Pile; most of the internet is garbage, and that garbage hints at why models are good at some output formats and not others.

At Notion AI the team first tried human-annotated logs and automated error detection. What they settled on for many features is more old-fashioned: engineers put time on the calendar every week, sit in a room, and stare at a Notion database of bad outputs reported by users. For each one they ask which step in the pipeline failed, what category it belongs to, and whether it is an existing bug, a new bug, or a systematic issue that needs a new invention. They treat model failures like software bugs.

The second tip is to invest early in internal tools that make it cheap to run evaluations, generate synthetic datasets, and sort through outputs. Those tools should not be so complex that an engineer cannot whip one up in a couple of days, because the payoff is being able to customize them as the product changes. Labenz agrees there is no substitute for looking at raw inputs and outputs. Automation only works after everyone shares a solid picture of what you are trying to detect.

Labenz closes on two trends: latent spaces that map onto one another, and models that can be merged in seemingly unprincipled ways. CLIP joined image and text; BLIP-2 froze a language model and an image model trained separately, then unlocked strong multimodal behavior with a small connector trained in a couple of GPU days. Relative-representations work suggests models trained on different shuffles still converge on isomorphic geometries, sometimes a rotation apart, and people have started adding fine-tuned weights together with surprising success. Lee does not have a fully principled account of merging, but he notes that many of these models are fine-tunes of one base, living in a linear subspace of the original, so merging is often interpolation. He once trained a linear adapter from OpenAI's embeddings into his own invertible model and could read out OpenAI vectors without spending a fortune on a custom inverter. He files the whole family of tricks as a compute-efficient way to customize a model that is already close enough.

Will models start talking to each other in high-dimensional activations instead of readable text? GPT-3, he says, is in some sense a hundred GPT-2s talking in activation space. If we learn how residual streams communicate, those techniques should generalize to mixture-of-experts models and to systems like BLIP-2. Mapping between fully formed embedding spaces may even be easier to interpret than a Transformer's residual stream, because the concepts that align images with text are more likely to be ones humans already have words for. He is more excited than alarmed.

Asked how weird the next few years might get, he reaches for MKBHD's line about Sora: this is the worst the technology is ever going to be. Language models will keep improving monotonically, which he finds interesting and scary. He agrees that long-term coherence and goal-directedness are the missing pieces for agents—models today still behave as if the world ends after the next turn. Culture is harder to predict. Citing a TEDx talk by creativity and HCI researcher Kate Compton, he notes that when a model can emit millions of images for one prompt, the artifact may no longer be a single blob of pixels but a subspace of possible outputs, bundled as a form of creative expression.

His own positive vision is not a day-in-the-life fantasy so much as a design principle. Any base technology can be packaged in an agency-taking way or an agency-amplifying way. A dishwasher takes away agency, and that is fine; nobody is creatively attached to dish order. Writing tools, emoji keyboards, predictive text, and social algorithms sit in a more dangerous middle. He does not think people are thinking hard enough about whether language-model products amplify agency or strip it. OpenAI, in his reading, sits toward replacement: its definition of AGI is something like a system that can take over a full human's job. Runway frames usefulness as extending what you want to express. There is healthy diversity. If the industry gets the packaging right, he remains optimistic.