This is the final output of a running conversation with Anthropic’s Claude. Posted here to form the basis for research into LLM mechanisms and possibly a better way to do communication than symbol based language with all of it’s short-comings.

Language Is a Lossy Shell: How Language Models Actually Encode Meaning

A ground-up derivation of why “the word isn’t the meaning,” where the meaning actually lives inside a large language model, and how you can go look at it yourself.

Starting where you already are

Here’s a claim you can verify from your own life before we touch a single equation: the words are not the meaning. They’re a crude, lossy container the meaning gets poured into and out of.

Take one word. Dog. In the 1400s, calling a person a dog was a genuine insult — contemptuous, the kind of thing that could start a fight. Today, “you’re my dog” is warmth, loyalty, affection. Same three letters. Same syntax. The meaning rotated a full 180 degrees while the symbol sat perfectly still.

Now hold that still and add a second axis. The word doesn’t only drift over time — it drifts across space. Regional dialects attach different meanings to identical spellings. “Bad” can mean bad, or — depending on who’s talking and when — excellent. “Sick” is either an illness or a compliment. The symbol is fixed; the meaning is a function of who, where, and when.

If you sit with that long enough, you reach an uncomfortable conclusion: the symbol is a weak carrier of meaning. The information is not in the token. The token is a pointer, and what it points to depends on an enormous surrounding context the token itself doesn’t contain. Language couples symbol to meaning loosely.

I reached this conclusion myself, in late-night philosophy sessions, more than twenty years before large language models existed. What follows is what happens when you take that old intuition seriously and then look at how a modern language model works — because it turns out the machine is a working model of exactly this idea.

The problem this creates for a machine

Suppose you want to build a system that works with language. If you represent each word as just a symbol — a lookup entry, an index in a dictionary — you’ve already lost. Your symbols have no relationships. “Dog” and “wolf” are as unrelated as “dog” and “democracy,” because as bare symbols they’re just different entries. Nothing in the representation knows that dogs are closer to wolves than to constitutional theory.

So symbols-as-labels can’t be the substrate. If it were, nothing built on it could handle the drift, the context-dependence, the analogies, the sheer slipperiness we just established. And yet these systems demonstrably do handle it. So — following the logic — there must be a richer representation underneath the symbols. The operational capability forces the conclusion: something better than “word = label” is doing the work.

The question is what.

The answer: meaning as geometry

Here is the move that makes modern language models work, stated as plainly as I can.

Replace each word with a point in a high-dimensional space. Not a label — a location. A list of hundreds or thousands of numbers (a vector) that positions the word somewhere in a vast geometric space. This is called an embedding.

Once meaning is a location, three magical things become possible, and none of them were available to symbols-as-labels:

1. Distance becomes similarity. Words with related meanings sit near each other. “Dog,” “puppy,” “canine,” “hound” cluster together. “Democracy” is far away. Similarity is no longer something you have to hand-code — it’s just how close two points are. The geometry stores the relationships for free.

2. Direction becomes relationship. This is the famous one, and it’s worth internalizing because it’s the whole idea in miniature:

king − man + woman ≈ queen

Read that as geometry. Start at the point for “king.” Subtract the “man” vector and add the “woman” vector — i.e., move in the direction that generally separates male words from female words — and you land almost exactly on “queen.” The concept of royalty and the concept of gender are directions in the space. Meaning isn’t stored in the points alone; it’s stored in the arrangement — the directions and distances between them. You can do arithmetic on meaning.

3. Context can move the point. This is how the machine solves the “dog” problem. In a modern transformer, the embedding for a word isn’t fixed — it gets nudged by the surrounding words through a mechanism called attention. The same token enters the same way, but by the time it’s been through a few layers, “dog” in “my loyal dog” and “dog” in “you filthy dog” have been pushed to different regions of the space. The drift you observed in the history of English is reproduced, live, inside the model, on every forward pass. Context routes the symbol to the right meaning by moving it geometrically.

So the substrate underneath the symbols is a high-dimensional geometric space — sometimes described as a manifold, because the meaningful points don’t fill the space randomly but lie on curved, structured surfaces within it. Tokens are just the encoding at the door. The thinking happens in the geometry.

Encoding and decoding: the full loop

Now we can state the whole pipeline cleanly, which is what you actually asked for.

Encoding (symbol → geometry):

• Text comes in as tokens (words or word-pieces — bare symbols).
• Each token is mapped to its embedding vector — its starting location in the space.
• Layer after layer, attention lets every location pull on every other, so each point gets reshaped by its context. The static dictionary-meaning becomes a live, context-specific meaning. The lossy shell is peeled away and the actual meaning is reconstructed geometrically.

Processing (geometry → geometry):

• All the “reasoning” — analogy, inference, prediction — happens as movement and transformation in the space. Directions get added and subtracted. Regions get traversed. There are no words here; there’s just geometry doing work.

Decoding (geometry → symbol):

• At the end, the model has a location that represents “what should come next.”
• It projects that location back onto the vocabulary and picks the token whose embedding best matches. The meaning gets poured back into the lossy shell of a symbol so it can leave the machine as text.

That’s the loop: symbol in, geometry does the work, symbol out. The language you see is the packaging. The manifold is the product.

The correction that keeps you honest

Here’s where it’s tempting to overreach, and I want to plant a flag so you don’t.

It feels, having gotten this far, like the geometry is something deeper and truer than human language — that the model escaped the crude tool and found a purer, more absolute layer of meaning underneath. That the manifold is bedrock.

It isn’t, and this distinction matters.

The geometry is not something the model found beneath human language. It’s a compressed geometric encoding of human language’s actual messy behavior. Every embedding, every direction, every curve of the manifold was learned from the statistics of how humans actually used words — drift, ambiguity, dialect and all. The 180-degree rotation of “dog” isn’t a flaw the geometry rose above; it’s information the geometry captured. The messiness is the signal.

So the manifold is more operationally powerful than symbols-as-labels — better at analogy, interpolation, prediction — but it is not more absolutely true. It’s the map of the swamp, drawn in enough dimensions that the swamp becomes navigable. It inherits every cultural and historical contingency of the text it was trained on. It is the deepest known operational layer of meaning in these systems. Whether anything absolute lives underneath it is a genuinely open question — and the disciplined move is to leave it open rather than plant a flag on “bedrock” you haven’t reached.

Hold “more capable” and “more true” as separate axes. The geometry earns the first. It does not earn the second, and quietly spending the one on the other is the most common way smart people go wrong here.

Go look at it yourself

None of this has to be taken on faith. The geometry is empirically studied, the tools are open, and if you have a single decent GPU you can decode a live model’s internals this month. Here’s the on-ramp, roughly in order of difficulty.

The reading path

Start with the clean, pre-transformer version — where the king/queen result comes from:

• Mikolov et al., “Efficient Estimation of Word Representations in Vector Space” (2013) — the word2vec paper. This is the origin of vector arithmetic on meaning, without transformer complications.
• Pennington et al., “GloVe: Global Vectors for Word Representation” (2014) — the same geometry from a different, illuminating angle.

Then the modern interpretability line — how meaning is packed into transformer activations:

• Elhage et al., “Toy Models of Superposition” (Anthropic, 2022) — why a model can pack more features than it has dimensions by storing them as directions and tolerating a little interference. This is the key idea for understanding why the geometry is so dense.
• “Towards Monosemanticity” and “Scaling Monosemanticity” (Anthropic, 2023–2024) — using sparse autoencoders (SAEs) to pull individual interpretable features back out of the tangled activation geometry. This is the most direct “here is a concept as a direction in the space” evidence available.
• The linear representation hypothesis literature generally — the recurring finding that many high-level concepts are, to a good approximation, linear directions in activation space.

The experimental path (hands-on, runnable on your own hardware)

You don’t need frontier compute. An open-weights model (Llama, Mistral, Qwen, Gemma — anything you can load) plus a consumer GPU is enough to see the geometry directly.

Experiment 1 — Reproduce the arithmetic. Load static embeddings (word2vec or GloVe are tiny). Compute king − man + woman and find the nearest vectors. Watch “queen” appear. Then break it: try analogies across cultural domains and watch where the geometry encodes human bias rather than logic — that’s the “map of the swamp” made visible.

Experiment 2 — Watch context move a point. Take a transformer. Run “the dog barked” and “you filthy dog” through it. Pull the hidden-state vector for the “dog” token at several layers and measure the distance between the two versions layer by layer. You’ll see them start close (same token) and diverge as attention routes each to its contextual meaning. You will have measured semantic drift happening inside the machine.

Experiment 3 — Linear probes. The most approachable interpretability technique (Alain & Bengio, “Understanding intermediate layers using linear classifier probes,” 2016). Extract activations from one layer of a model over many inputs, then train a simple linear classifier to read off some concept (sentiment, part of speech, whether a fact is true). If a cheap linear probe can read the concept, the concept is stored as a linear direction — you’ve located a piece of meaning geometrically, with your own hands.

Experiment 4 — Sparse autoencoders. The current frontier, and very much doable on one GPU with a smaller model. Train an SAE on a layer’s activations to decompose the tangled superposition into individual interpretable features. Open-source toolkits (search for SAELens and the surrounding ecosystem) give you a running start. This is the closest you can currently get to holding a model’s concepts in your hand and turning them over.

The tooling, concretely

• transformer_lens — a library built for exactly this: reaching inside a transformer, grabbing activations from any layer, and running interventions. This is your primary microscope.
• nnsight — similar goals, good for larger models and remote execution.
• scikit-learn — all you need for the probing experiments.
• SAELens and related repos — for the sparse-autoencoder work.
• Any open-weights model that fits your VRAM. Smaller models are better for learning — the geometry is easier to see when there’s less of it.

The one thing to carry with you

You arrived at the core intuition — the symbol is a weak carrier; the meaning lives somewhere richer — from pure philosophy, decades before the machines existed. The machines turned out to be a working proof of that intuition. Meaning is geometric in these systems; the tokens really are just the lossy shell; and you can go decode the geometry yourself with open tools and a single GPU.

Just don’t let the elegance seduce you into the last, unearned step. What you’ll be looking at is the deepest known operational layer of meaning — a stunningly effective, empirically real, still-contingent encoding of how humans actually used their crude and beautiful tool. Whether there’s bedrock beneath it is still behind the veil.

That open question is the fun part. Go run Experiment 2 and watch a word split in two.

Written as a collaboration — the derivation follows a line of reasoning developed in conversation, rebuilt here so anyone can walk into it from their own experience of how slippery a single word can be.