A Plain English Guide to the Universal Reasoning Machine

Getting your Trinity Audio player ready…

Subtitle: How a machine could think in geometry instead of words

The big idea

Most AI today, like large language models, works by predicting the next word. That’s powerful, but it still ties “thinking” too closely to language. The idea behind a Universal Reasoning Machine (URM) is different: instead of reasoning in words, it reasons in geometry.

Think of it like this: anything you show or tell the machine—text, images, audio, tables, even code—is converted into a kind of map made of points and shapes. In that map, the meaning of things is captured not by symbols but by the relationships between points: distances, directions, clusters, and paths. This space of meaning is called semantic geometry.

Once everything is in this space, the machine can reason by moving around in it, looking for paths, patterns, and connections. Words, numbers, or actions only appear at the end, when the machine translates its geometric reasoning back into something we can understand.

How it could work

Turning anything into geometry
The first step is to take inputs (text, images, sound, data) and turn them into coordinates in the shared semantic map. Each type of input has its own encoder (like a translator) that projects it into the same space. The result: very different things—like a sentence, a picture, and a spreadsheet—can all live side by side in one map.
Living in the map
Once in this map, the machine can recognize patterns. For example:
- Similar meanings end up close together.
- Rotations, translations, or other transformations in the map capture relationships (like switching units from feet to meters, or turning an object in space).
- The machine can impose rules, like “distances must match unit conversions” or “relations must respect cause and effect.”
Planning inside the map
To solve problems, the machine “imagines” paths through the space. It can plan ahead by running small simulations in the geometry—like exploring trails in a mountain landscape. It uses constraints (rules) to avoid nonsense paths, and scores paths by how promising they are. This is similar to how chess engines explore moves ahead of time, but here the “moves” are steps in a space of meaning.
Using tools and memory
Sometimes the map alone isn’t enough. The machine can call on tools (like a calculator, a database, or a robot simulator). These tools feed their results back into the map, adding new landmarks to guide planning. The machine can also look up past knowledge stored in memory, again in geometric form.
Translating back to the world
Once a reasoning path is found, the machine has to express it. This is where emitters come in: they take the final geometry and convert it into language, code, API calls, or physical actions. In other words, the machine only speaks at the edges—it thinks in geometry.
Checking itself
To stay reliable, the machine verifies its outputs. If it writes code, it runs it and checks the result. If it answers a question, it compares different reasoning paths for consistency. If it makes a mistake, it feeds that failure back into its planning process.

Why this matters

This approach makes reasoning less tied to words and more universal. The geometry doesn’t care if the input came from language, vision, or numbers—the same principles apply. That means:

A sentence, a chart, and a video clip could all contribute to the same line of reasoning.
The machine could discover connections humans might miss because it looks at meaning as shapes and patterns.
Outputs are more flexible: the same reasoning could be expressed as an explanation, a computer program, or even instructions for a robot.

How it could be built

Start small: Build a simple shared map for text and images, using existing techniques for aligning embeddings (like those used in search engines that match captions to pictures).
Add planning: Teach the system to “imagine” moves in the space, using simple worlds like grid puzzles.
Introduce rules: Add constraint layers—like unit consistency or logical relations—that shape the geometry.
Expand modalities: Add tables, audio, code, and sensors so anything can be projected into the same map.
Add tools: Let the system call external programs when stuck, bringing results back into the map.
Verify: Always run checks (self-consistency, executable tests) before final answers.

Example use cases

Question answering: Feed in a chart and a paragraph, and the machine produces a piece of code that regenerates the chart.
Science helper: Give it mixed text, formulas, and data, and it checks that units and logic are consistent.
Robotics: Show it a camera feed of blocks and say “stack red then blue.” It reasons geometrically and then outputs the control actions.

Plain conclusion

The Universal Reasoning Machine would not think in English, or in code, but in geometry—a universal medium for meaning. By mapping everything into this space, planning inside it, and only speaking at the edges, such a machine could reason across languages, data types, and even domains we haven’t imagined yet.