Working Paper: Towards a Category-theoretic Comparative Framework for Artificial General Intelligence

This position paper proposes a novel category-theoretic framework to formally define, compare, and analyze diverse Artificial General Intelligence architectures, aiming to unify their structural and behavioral properties while identifying commonalities, differences, and future research directions.

The Gist

Imagine you are trying to build the ultimate "Universal Robot" (Artificial General Intelligence, or AGI). Right now, scientists are building many different versions of this robot. Some use Reinforcement Learning (like training a dog with treats), others use Causal Reasoning (understanding why things happen), and some use Schema-Based Learning (organizing knowledge like a library).

The problem is that these robots are built using different blueprints, different languages, and different math. It's like trying to compare a Ford assembly line, a Swiss Army knife, and a solar-powered drone by just looking at their engines. You can't easily tell which one is better, how they relate, or how to upgrade one into the other.

This paper proposes a new way to look at all these robots using a branch of mathematics called Category Theory. Think of Category Theory not as a calculator, but as a universal translator and a structural blueprint tool.

Here is the breakdown of their idea using simple analogies:

1. The Blueprint vs. The Building (Architecture vs. Agent)

The authors make a crucial distinction between the Blueprint (the Architecture) and the Building (the Agent).

• The Architecture (The Blueprint): This is the design. It says, "We need a door here, a window there, and a pipe connecting the kitchen to the bathroom." It doesn't say what material the door is made of (wood or steel) or who installs it. It's just the rules of connection.
• The Agent (The Building): This is the actual robot running the code. It's the house built from the blueprint, with specific bricks, paint, and furniture.

The Paper's Goal: Instead of comparing the specific houses (the agents), they want to compare the blueprints (the architectures). This allows them to see if two very different robots are actually built on the same fundamental design, or if one is just a slightly modified version of the other.

2. The Two Layers: The "Wiring" and the "Brain"

The authors split every robot's blueprint into two distinct layers:

• Layer 1: The Wiring (Syntax): This is the flowchart. It answers: "Does the robot look at the camera, then think, then move its arm?" It's the order of operations.
• Layer 2: The Brain Content (Knowledge): This is what the robot knows and how it changes that knowledge. Does it have one giant notebook where it writes everything down? Or does it have a library with separate books for "weather," "cars," and "people"?

The Analogy: Imagine a Doctor's Office.

• The Wiring: Every patient goes through the same flow: Check-in -> Examine -> Diagnose -> Prescribe -> Pay. This is the "Syntax."
• The Brain Content:
  • Doctor A has a single, giant notebook. Every time they see a new symptom, they just add a line to the bottom. (This is like Reinforcement Learning: simple, but messy).
  • Doctor B has a library. If they see a new disease, they create a new book for it. If they see a similar disease, they cross-reference existing books. (This is like Schema-Based Learning: organized and modular).

The paper argues that to build a truly smart AGI, we need to move from Doctor A's notebook to Doctor B's library, and we need a mathematical way to prove why the library is better.

3. The "Universal Translator" (Category Theory)

How do they compare these different blueprints? They use Category Theory.

Think of Category Theory as a Lego Master.

• In the Lego world, a "Category" is just a set of Lego bricks and the rules for how they can snap together.
• The authors treat every AI architecture as a specific set of Lego instructions.
• Reinforcement Learning is a set of instructions for building a simple car.
• Causal Learning is a set of instructions for building a car with a GPS.
• Schema Learning is a set of instructions for building a modular robot that can swap its own wheels and engines.

Using this math, they can draw a "map" showing how to take the instructions for the simple car and transform them into the instructions for the modular robot. They can see exactly where the simple car is missing a piece (like a GPS) and how to add it without breaking the whole thing.

4. The Evolution of Intelligence (The Case Studies)

The paper walks through a "family tree" of AI architectures to show how they evolve:

1. Reinforcement Learning (The Toddler): The robot learns by trial and error. It has one big brain (a single parameter) that updates every time it gets a reward. It's simple but gets confused easily because it can't separate "good ideas" from "bad ideas."
2. Causal Reinforcement Learning (The Teenager): The robot now has two brains: one for "what to do" and one for "why things happen." It can ask, "If I push this button, what happens?" It's smarter because it understands cause and effect, but it's still a bit rigid.
3. Schema-Based Learning (The Adult): The robot has a modular mind. It doesn't just have one brain; it has a library of "Schemas" (mini-programs).
   • It has a "Driving Schema."
   • It has a "Cooking Schema."
   • It has a "Social Schema."
   • It can pick the right one for the situation, combine them, or even write a new one if it encounters a new problem. This is the closest thing to human-like general intelligence.

5. Why This Matters

The authors claim that AGI (Artificial General Intelligence) isn't just about making a bigger computer or writing a better algorithm. It's about structural organization.

• If you keep using the "One Big Notebook" architecture (Reinforcement Learning), you will hit a wall. The robot will forget old things when it learns new things (Catastrophic Forgetting).
• To get to AGI, we need to switch to the "Library" architecture (Schema-Based Learning), where knowledge is organized, reusable, and modular.

The Big Promise

The paper concludes with a symbiotic relationship:

• AGI needs Math: We need this "Category Theory" framework to stop guessing and start proving which robot designs will actually work.
• Math needs AGI: Category Theory is a powerful but abstract tool. AGI provides a massive, real-world playground to test and refine these mathematical ideas, potentially making Category Theory the new "standard language" of science.

In short: The paper is a proposal to stop building AI robots by trial and error and start building them with architectural blueprints that we can mathematically compare, upgrade, and prove will lead to true general intelligence.

Technical Summary

1. Problem Statement

Artificial General Intelligence (AGI) encompasses a heterogeneous family of agent models (e.g., Reinforcement Learning, Universal AI, Active Inference, Causal RL, Schema-Based Learning). Despite sharing a structural intuition—that an agent is a compositional system transforming perceptions into actions while updating internal states—there is currently no formal framework to:

• Compare different AGI architectures rigorously.
• State precise relationships (embeddings, translations, or reductions) between them.
• Derive structural guarantees independent of specific implementations.
• Identify principled reasons for empirical differences between architectures.

Existing theories provide internal results (e.g., convergence in RL) but fail to explain how these theories relate to one another or how an agent in one formalism can be translated into another.

2. Methodology

The authors propose a Category-theoretic framework based on Hypergraph Categories and Grothendieck Fibrations. The core methodology involves treating an architecture not as a concrete algorithm, but as an algebraic theory of computational interaction.

Core Formalism

• Architectures as Algebraic Theories: An architecture is defined as a Free Hypergraph Category generated by:
  • Types (Ports): Interfaces (perception, action, memory).
  • Generators (Modules): Primitive computational units (policy, inference, learning updates).
  • Equations: Structural wiring patterns (Frobenius algebras for copying/merging/feedback).
• Dual Dimensions: The framework explicitly separates two orthogonal but coupled dimensions:
  1. Syntactic Structure: The compositional flow of modules (how perception connects to action).
  2. Epistemic (Knowledge) Structure: The types of knowledge units available and the transformations allowed over them (e.g., updating, combining, discarding).
• The Profunctor Interface: A profunctor ($\Phi$) relates the syntactic category to the knowledge category, specifying where and how operational modules interact with internal knowledge resources without committing to specific representations.
• Agents as Functors: Concrete agents are defined as Monoidal Functors ($F: \mathcal{H}_A \to \mathcal{Sys}$) that interpret the abstract architecture within a semantic universe (e.g., stochastic kernels, differentiable operators).
• The Fibration: The framework organizes into a Grothendieck Fibration $p: \text{Agents} \to \text{ArchAgents}$, where the base category contains architectures and the fibers contain their compatible implementations. Morphisms between architectures induce reindexing functors, allowing agents to be translated across different formalisms.

Properties and Verification

The paper introduces a mechanism to attach Semantic Certificates to agents using Institutions (a logic-independent framework for formal semantics). This allows:

• Structural Properties: Derived purely from the architectural wiring (e.g., existence of feedback loops).
• Informational Properties: Derived from the knowledge category structure.
• Semantic Properties: Verified via external mathematical proofs (e.g., convergence, causality) attached to specific agent implementations via "proof-carrying" certificates.

3. Key Contributions

A. The ArchAgents Category

The authors define a category where:

• Objects are Agent Architectures (triples of Syntax, Knowledge, and Interface).
• Morphisms are structure-preserving translations between architectures.
• This enables the study of Architectural Equivalence, Reduction (e.g., showing RL is a sub-architecture of Causal RL), and Expressivity.

B. Case Studies: A Spectrum of Architectures

The paper applies the framework to four distinct architectures, demonstrating a progression from simple to complex cognitive structures:

1. Reinforcement Learning (RL): Characterized by a monolithic knowledge carrier ($\Theta$). All knowledge is collapsed into a single parametric update. It lacks modularity and causal structure.
2. Causal Reinforcement Learning (CRL): Introduces a dual knowledge structure separating Policy parameters ($\Theta_\pi$) and a Causal World Model ($\Theta_{CS}$). It supports intervention (Do-calculus) but remains globally coupled.
3. Schema-Based Learning (SBL): The most expressive architecture. It features:
   • Modularity: Knowledge is distributed across a family of Schemas (Perceptual, Motor, Predictive, etc.).
   • Compositionality: Schemas can be composed to form higher-level abstractions.
   • Locality: Updates apply only to active schemas, preventing catastrophic forgetting.
   • Body-Mind Mediation: Explicit separation between raw sensory inputs and structured mental representations.
4. AIXI: Formalized as an architecture with a universal predictive kernel and historical memory, highlighting its specific informational constraints.

C. The "Stepwise Relaxation" Analysis

The authors demonstrate that SBL emerges from CRL (and CRL from RL) not by abrupt replacement, but by the stepwise relaxation of architectural constraints:

• Relaxing interface atomicity (factorization).
• Relaxing model uniqueness (multi-model).
• Relaxing update atomicity (cognitive modules).
• Relaxing temporal synchrony (memory).
• Relaxing direct environment coupling (Body-Mind mediation).

D. Extended Definition with Constraints (Appendix)

The paper proposes an extension to include Architectural Constraints ($R_A$) as a distinct layer. This allows architectures to enforce mathematical conditions (e.g., Bellman equations, Markovian transitions, factorization) that are not purely syntactic but essential to the architecture's identity. This distinguishes between the syntax of the architecture and the normative constraints on its valid implementations.

4. Results

• Unified Formalism: Successfully mapped diverse AGI paradigms (RL, CRL, SBL, AIXI) into a single categorical language, revealing their structural similarities and differences.
• Comparative Analysis: Provided a rigorous way to compare architectures based on:
  • Feedback Structure: Single loop (RL) vs. Coupled loops (CRL) vs. Decoupled loops (SBL).
  • Knowledge Modularity: Monolithic vs. Factorized vs. Compositional.
  • Causal Representation: Absent vs. Explicit vs. Modular.
• Translation Mechanism: Demonstrated how morphisms between architectures allow for the re-indexing of agents, theoretically enabling the translation of an agent from a Causal RL framework into a Schema-Based framework (or vice versa) while preserving structural properties.
• Property Inheritance: Showed that structural properties of an architecture are functorially stable; if an architecture has a property, agents implementing it inherit it (subject to semantic certification).

5. Significance

• Theoretical Foundation for AGI: Moves the field from empirical benchmarking to a unified formal foundation. It allows researchers to reason about AGI capabilities (like continual learning or causal reasoning) as architectural properties rather than just algorithmic tricks.
• Symbiotic Relationship: The authors argue for a symbiotic relationship: AGI benefits from the rigorous structural analysis of Category Theory, while the complexity of AGI drives the development of new frontiers in applied Category Theory (specifically in open dynamical systems and cybernetics).
• Design Principles: The framework provides a toolkit for designing new AGI architectures by identifying minimal canonical patterns (generators) and systematically relaxing constraints to achieve desired cognitive capabilities.
• Future Roadmap: The paper outlines a clear path for future work, including the formalization of environments (World category), empirical measurement tools, and the development of a collaborative experimental platform to test these theoretical comparisons.

In summary, this paper establishes a Category-theoretic "Periodic Table" for AGI architectures, offering a precise language to decompose, compare, and synthesize the structural and informational laws governing intelligent agents.