Beyond Language: Making Machines Think in Molecular Concepts

When we ask an AI model to solve a hard problem today, we make it do something odd: talk to itself. To keep its train of thought it uses words as a scratchpad, writing whole pages in English or Italian and dragging grammar, commas, and synonyms along at every step (“therefore”, “thus”, “in conclusion”).

The trouble is the format itself. In everyday speech, the word “water” is a closed label, as mute as a warehouse key like ID_4821: it hides what it is made of and how it reacts. Writing H₂O is still a language, just a molecular one. It shows the atoms (H, O), their ratios, and valid bonds, so you can work out a reaction on paper without tasting every test tube.

Bringing this idea into machines means letting them work in a molecular language made of knowledge atoms, keeping English or Italian at the edges only to talk with us. And we are not starting from nothing: centuries of physics, law, code, and abstract ideas already live in human texts. From there we can pull out that table while stripping syntactic habits.

Back in 2006, when I wrote about Links as Information Flow and Markov Chains, I kept circling the same issue: chaining probable words yields fluent prose that has no grasp of what it is saying.

One note before going further: this remains a theoretical hypothesis, I have not trained a model at scale. The simulators below are just there to show the idea in practice.

To build a molecular language, we first need to agree on what counts as an atom. A house, a stone, or a lemon are not atoms: they are finished objects put together from smaller traits. Putting “lemon” or “webinar” on base axes would be like walking into a print shop with a jar labeled “Mona Lisa’s Face” instead of cyan, magenta, and yellow.

On everyday sentences this mistake shows up fast. Let the model invent free labels and it cheats with custom categories tailored to the passage it just read; lock it into vague buckets and “Today I am hosting a webinar for entrepreneurs” ends up in a generic bin about work. You have to go down to indivisible traits: size, roundness, acidity, bitterness, sweetness, and solidity. With zero “citrus” slot, values along those sides separate a lemon from a grapefruit (larger, rounder, less acidic, and more bitter).

None of this is a return to 1970s hand-crafted ontologies (GOFAI), where committees tried to catalog the world at a desk and drowned in exceptions. Here axes emerge by compressing real data and survive only if they sharpen deductions. Compare them below.

Once the bricks are isolated, geometry follows on its own. A single atom—say size, running from small (-1) to large (+1)—is a segment. With acidity it becomes a square, with bitterness a cube, and one side per trait builds a hypercube (n-cube). Each point locks a precise mix of traits, and moving along one side shifts one property while holding the others steady.

Even teams trying to move past words today often stop halfway. Systems like Coconut already step through continuous latent space without printing words, while LCM and SONAR project whole sentences into shared multilingual spaces.

The catch is that a dense vector stays opaque: coordinates tangle together, no axis carries a meaning you can inspect, and nothing stops an absurd state before it comes out. Keeping sides separate with hard sparsity forces more work upfront, though at least you can inspect each step and see what happened.

Each axis also needs to settle a practical trap. On temperature, lukewarm water sits at 0 because someone measured it; water inside a closed bottle is unknown; the number 5 has no temperature at all. Setting all three to zero would make them identical, so the space splits them: lukewarm sits at the center on the active base, unknown stays an open band along that base, and the number 5 rises to the neutral apex as the “not applicable” slot.

A space of smooth gradients tells heavy apart from light, yet stalls on “5 apples” or “5.25 kilos”, where an exact number matters.

To write numbers without words we use the same principle as digital maps (Geohash), tightening the frame one zoom level at a time down to a single street. Exact 0 is 000 and 5 is 101 (4 + 0 + 1 = 5). Halving steps past the decimal (0.5, 0.25...) reaches 5.25 kilos, and prepending powers of two (16, 32, 64...) scales up. Dropping trailing bits widens the view to “roughly 5 kilos” without losing the center. Inside the fixed matrix, this binary code lives inside the active atom’s slot so it does not burn extra slots.

The same channel separates absolute amounts from differences: apples, kilos, or kelvin hit an unbreakable physical zero (-5 apples gets blocked right away), whereas a minus sign applies only on shifts like -5 degrees compared to yesterday.

A twin rule anchors proper names like Mario. Instead of reducing him to an anonymous database ID, Mario gets a steady address among specific individuals: if he shaves his head, visual traits update while who he is stays put.

A single point describes an object or person well (Mario, Sara, 50 euros), yet falls short once multiple actors enter the scene. “Mario pays Sara” and “Sara pays Mario” use the exact same pieces for opposite facts, just like “The mailman bites the dog” versus “The dog bites the mailman”.

That is why we need directed arrows. Inside the fixed matrix each entity takes a row, and an action becomes a direct bond between concept rows (actor → action → recipient). Flipping the arrow swaps payer and recipient while leaving Mario’s and Sara’s coordinates untouched. Logical operators (not, if...then, or) work on those bonds without polluting axis zeroes: saying “not lukewarm” applies not to the bond with 0, ruling out the center without pretending temperature is unknown.

When a network of arrows keeps repeating—two people, a sum, a deadline, and an if...then clause—the space wraps it into a reusable box, a composite concept like loan, contract, or reckless intent. That nested assembly—in practice a typed graph packed inside the fixed matrix—is what avoids the explosion into hundreds of thousands of columns seen in flat Sparse Autoencoders: chemistry builds millions of molecules out of roughly a hundred atoms without widening the periodic table, and here the cap of a few active slots applies per elementary node rather than squashing an entire contract onto a single row. In fast steps you use the box closed; whenever you need to check what is inside, you open it. Test it below.

Keeping axes separate switches on a chemistry of valences across concepts. Physically boiling or scorching requires physical matter: faced with “a heated debate”, zero materiality turns off thermal heat and routes the bond onto figurative sense without hand-written rules.

In practice two useful things happen along with a net saving. Absurdities get stopped before a word comes out (you cannot make water carry apples or heat a number with fire). Meanwhile, reading “something is scorching inside the closed box”, the system turns on materiality on the hidden item by itself. And during reasoning it does not have to generate bridging prose at all: it only updates the coordinates that change.

Only once calculation finishes does the linguistic translator step in. Every single event occupies one point on the time cursor (before, now, after), so “yesterday I will go” becomes impossible, while “by tomorrow I will have finished” links two points with a before arrow. Combine subjects, properties, and time below.

Architecturally, the work splits across three separate models: an encoder bringing texts, measurements, and sensors into the molecular matrix; a reasoning engine computing purely on coordinates; and a decoder that eventually writes the outcome in the reader’s language and units (paraphrasing if a single word is missing, or halting if a rule breaks).

Training runs in alternating frozen phases.

In the first phase, only the encoder and blind decoder work: they translate statements out of a language L_A into a randomly sampled target language (L_B ≠ L_A). Because all human languages share lexical shortcuts—translating “water” into Japanese or Arabic alone would just mint a single [WATER] token instead of breaking it down—the bridge is forced to land on the exact same coordinates whether it reads a single word or its definition and physical traits written without naming that word, alongside code and measurements. It has to keep only 5–10 slots active per node inside a GPU-friendly fixed rectangular matrix (the rest stays on not applicable), move as little as possible on a single axis, and open a new column when residuals—flagged by reconstruction loss or a calibrated Decision Model—show the exact same detail is missing again and again.

In the second phase, that bridge freezes and only the engine trains on direct request → outcome trajectories (deductions, math, executable code, cause-and-effect transitions), with zero intermediate words. That is where real selection happens: a new axis stays in the table only if it raises accuracy and cuts steps on unseen problems. And whenever the engine keeps failing specific deductions because the first phase left two distinct physical traits fused inside one linguistic column, that deductive error feeds back into the next first-phase pass as a split directive to divide the coarse axis.

When a language model today balloons to hundreds of billions of parameters, almost all of that space acts as a warehouse for things no formula can compress: vocabulary across dozens of languages and millions of arbitrary facts, like the year Garibaldi died or a neighborhood postal code.

Detach vocabulary and encyclopedic trivia from the reasoning engine, and that engine works like a computer CPU separated from its hard drive. Inside its weights it stores zero words and zero trivia; it keeps only transformation laws across atoms, such as knowing that handing away an apple leaves you empty-handed while sharing a piece of information leaves both people with it. That is why the engine itself can be built from scratch while staying tiny and fast, leaving language and human knowledge at the borders: there it makes sense to lean on existing trained models to extract the axis table upstream and translate inputs with a fixed gauge, keeping the input translator from reasoning on its own so the same statement always lands on the exact same coordinates.

At the exit, an even cleaner payoff kicks in. The few active atoms, exact numbers, and arrows behave like pure semantic radicals in Chinese characters stripped of phonetic pieces: if the engine starts at liquid water at +20 °C and subtracts thirty degrees, it lands on solid water at -10 °C without ever knowing the words “ice” or “frost”. Hand that final polytope to any language model downstream, and those few active traits are enough to write the exact word in Italian, English, or Chinese with zero vocabulary limit.

What can a memoryless CPU actually answer? Faced with pure recall (“What is the capital of Peru?”), on its own it stops on unknown instead of making up a plausible answer; wherever the facts already sit in the prompt, it computes a fresh outcome. On mixed questions—“Does a gallium spoon held in a living hand melt?”—either the input bridge already loaded known thermal traits (29.7 °C against 37 °C, flipping state to liquid without knowing what gallium is), or the three states seen earlier trigger external tools automatically without training the engine to write search queries. Measured computes straight through; not applicable blocks absurd lookups; and whenever an axis needed for the current step sits on unknown, the runtime pauses the engine, runs a targeted lookup on a database or the web just to fill that single cell, and resumes calculation. To keep everyday situations from stalling over dozens of unstated background details—say a glass drops without specifying marble or carpet—two operating modes stay distinct: on exact tasks (math, contracts, code) unknown halts and fetches hard facts, whereas on everyday common sense it fills a revocable typical estimate while tagging the final answer as probable rather than verified.

Removing words wipes out verbal reflexes right away: in the classic wolf, goat, and cabbage riddle, specify that this particular wolf only eats carrots and a text model will often ignore the clause and recite the solution memorized online. Inside the matrix the word “wolf” disappears, leaving only eats → carrots, so the verbal cliché has nothing to grab onto.

Still, assuming that dropping words automatically yields real reasoning would be naive. Any gradient-trained network is lazy by nature and will hunt statistical shortcuts across raw coordinates too: if nearly every training scene pairing a liquid with a heat source ends in boiling, an engine trained to leap straight to the final state memorizes that coordinate association, skips physics, and fails the moment you heat a -40 °C liquid for two seconds.

Forcing the engine to actually calculate means blocking memorized endings: it has to apply the same small local rule step by step with shared weights, train on counterfactual pairs where flipping a single atom (duration, sign, arrow direction) reverses the outcome, and take a loss penalty whenever it guesses instead of leaving an underdetermined output on unknown. And to rule out any suspicion that one of the border language models solved the puzzle behind the scenes, one test rule settles it: the final decoder stays completely blind to the initial question. It receives only the final polytope coming out of the engine, never the problem text; if the answer is right, only the engine could have worked it out (once that benchmark passes, in real conversation the verbalizer can read dialogue tone again while staying strictly bound to the facts locked in the polytope).

The hardest mathematical hurdle—the same wall neuro-symbolic systems have faced for years—sits right here: pushing gradients across discrete choices (not applicable, zoom bits, arrows, boxes) without killing axes early on or sliding back into dense opacity, starting from gradual sparsity annealing. The decisive test will be running this cycle on a closed counterfactual domain on a single GPU and measuring it head-to-head against both a word-reasoning model and a dense latent one.