White-Box AI: An Architectural Path to General Intelligence

J. Rogers, SE Ohio

The Problem with Black Boxes

The current generation of AI, dominated by Large Language Models (LLMs), is incredibly powerful. These systems can write poetry, summarize documents, and generate code. But they have a fundamental problem: they are "black boxes." Their knowledge is a complex, statistical pattern tangled across thousands of unnamed dimensions in a "latent space." This architecture makes them inherently opaque, untrustworthy, and, most importantly, uneditable. One cannot simply correct a fact inside an LLM; the concept doesn't exist. To change the model's mind requires a costly and unpredictable retraining process.

This paper presents an alternative paradigm: a "white-box" framework built on the principles of category theory. It's an approach where knowledge is explicitly architected, not statistically inferred. The argument here is that this model is not just a useful tool, but a necessary foundation for building systems that can reason, self-correct, and evolve—the foundational steps toward Artificial General Intelligence (AGI).

The Core Idea: A Library of Concepts

At its heart, the framework is built on a simple, intuitive idea: knowledge should be organized. It treats concepts as if they were books in a library, each with a precise location on a set of shelves.

These "shelves" are the named axes of a high-dimensional "conceptual space." Each axis represents a fundamental trait—is_mammal, can_fly, breathes_fire, threat_level. A concept, or "archetype," like a dragon, is defined as a vector—a set of coordinates that specifies its position along each of these axes.

When the system encounters an unknown observation (e.g., a creature that breathes fire and flies), it also plots it as a vector in this space. The process of "classification" is then reduced to a simple geometric measurement: calculating the cosine similarity, or the angular alignment, between the observation's vector and every known archetype. The archetype with the highest alignment is the closest conceptual match.

This is a direct, practical implementation of category theory. The concepts are the Objects. The similarity scores are the Morphisms (the arrows or relationships) between them. The entire system is built to model the structure of knowledge and the relationships between ideas.

The Crucial Difference: An Editable Mind

This is where the distinction from an LLM becomes critical.

An LLM's latent space has unnamed, overlapping dimensions. The concept of a "dragon" is a diffuse pattern, not an addressable object. One cannot point to a single coordinate and say, "This is the 'breathes_fire' axis."

In the white-box framework, that is exactly what one can do. The breathes_fire axis is an explicit, orthogonal dimension in the conceptual space. This architectural choice has profound consequences. To teach this system that the dragons in a specific world are different—for example, that they breathe frost instead of fire—one doesn't need to retrain a massive model. One simply edits the "dragon" archetype's data file, changing its coordinate on the breathes_fire axis to 0.0 and adding a coordinate on a breathes_frost axis. The change is surgical, predictable, and instant.

The system's knowledge is not a set of learned weights; it is a database. And databases can be edited.

The Path to AGI: Self-Modification

The idea that a system becomes an AGI when it is large enough to modify its own vectors is the central thesis. This act of self-correction is the hallmark of true intelligence, and it is something a black-box system is incapable of performing. The white-box framework, however, is designed for it.

Consider this workflow, which is impossible for a traditional LLM but natural for this categorical system:

1. Ingestion: The system encounters a new piece of information: "This text describes a Wyvern. It can fly and is a reptile, but it does not breathe fire."

2. Reasoning: It encodes "Wyvern" as a vector and, using its existing knowledge, classifies it. The closest match, or strongest morphism, is to "Dragon."

3. Introspection: The system is not finished. It then compares the Wyvern's vector to the Dragon's vector. It programmatically detects a significant conflict on the breathes_fire axis. It concludes, "My current classification is imprecise because my knowledge base is incomplete."

4. Self-Modification: The system acts on this conclusion. It writes a new wyvern archetype into its bestiary.json knowledge base. It has permanently and deliberately altered its own foundational vectors based on new information.

This loop—Ingest, Reason, Introspect, Self-Correct—is the engine of growth. It is a process that requires a system to be able to treat its own knowledge as addressable, editable data.

Conclusion: The Symbiosis of Two AIs

While this white-box framework has the potential to be a replacement for the reasoning core of current LLMs, its most powerful immediate application is in symbiosis. The LLM, with its unparalleled ability to handle unstructured language, acts as the perfect Ingestion Engine, parsing raw text into the structured JSON that the white-box system needs.

Once that knowledge is structured, the Reasoning Engine takes over. It is this categorical framework that can then perform the deterministic, explainable, and—most importantly—self-modifying operations on that knowledge. The path to AGI may not be through building ever-larger black boxes, but through pairing them with transparent, white-box reasoning systems that can introspect, adapt, and grow.