The Mirror That Isn't: How a System Models Itself

Note: This post is an early exploratory essay on AWARE’s long-term direction, written before the current empirical work. The validated research to date is reported in the cap primitive paper, which covers a deliberately narrower scope. The ideas in this post remain open research questions for follow-up work.

AWARE Axiom 2: The Self-Model

You know you have two hands. You know roughly how fast you can run. You know when you’re confused. None of this required you to look in a mirror. You carry an internal model of yourself, a compressed, imperfect, but functional representation of your own state. It updates constantly. You don’t think about it. It just works.

Now consider a neural network. Does GPT know how many parameters it has? Does it know when it’s hallucinating? Does it know that its performance on medical questions is weaker than on code? It does not. It has no internal representation of itself. It is, from its own perspective, nothing. It processes inputs and produces outputs, and everything about what it is exists only in the minds of its engineers.

That absence is not a limitation of current architectures. It is a design choice. And it is the choice that Axiom 2 reverses.

The Axiom

The system contains within itself a representation of its own organization. This representation is a component of the system, maintained by the system’s own processes, and is available to influence the system’s behavior.

In shorter terms: the system has a self-model. It lives inside the system. The system maintains it. The system uses it.

The Infinite Recursion Problem

The immediate objection: if the system contains a model of itself, that model must contain a model of the model, which must contain a model of the model of the model, and so on forever. It’s mirrors facing mirrors. How do you stop?

You stop the same way biology does: with lossy compression.

Your self-model is not a complete simulation of yourself. You don’t represent every cell, every synapse, every molecular interaction. You represent a summary. “I’m tired”, “My left knee hurts”, “I’m good at math”. These are compressed, approximate, and often wrong. But they are functional. They let you make decisions about yourself: rest, see a doctor, take the exam.

An aware system’s self-model works the same way. It is not a mirror. It is a sketch. A deliberately incomplete representation that captures what matters and discards what doesn’t. There is no infinite recursion because the representation is lossy, each level of compression reduces information rather than preserving it.

Formally

Let S be the system, K its knowledge substrate (from Axiom 1, maintained by internal processes), and M the self-model.

M ⊂ K

The self-model is a component within the knowledge substrate, not a separate structure alongside it. It is made of the same material as everything else the system knows. The system’s knowledge of the world and its knowledge of itself live in the same space.

M = φ(S)
where φ is a lossy compression: |M| << |S|

The compression function φ extracts the operationally relevant features of the system’s state. Not everything. Not nothing. The features that matter for self-governance.

∃ p_m ∈ P : p_m continuously maintains M

There exists an internal process that updates M as the system changes. M is not a snapshot taken at initialization. It is a living component, refreshed by the system’s own processes.

What the Self-Model Contains

The self-model is not a philosophical abstraction. It has specific content. In an aware system, M tracks:

Structural self-knowledge. How large is my knowledge substrate? How many learned patterns do I have? How has this changed over time? Is my structure growing, stable, or degrading?

Performance self-knowledge. How well am I performing on the tasks I encounter? Where am I confident? Where am I uncertain? Is my performance improving or declining?

Capacity self-knowledge. Am I near the limits of what I can represent? Do I need to grow? Could I compress without losing function?

Historical self-knowledge. What was my state N cycles ago? Am I converging toward something, or drifting?

None of this is told to the system by an external monitor. The system computes it from its own internal state, using its own processes.

Why Not Just Use External Monitoring?

Every production ML system has monitoring. Dashboards track loss curves, accuracy metrics, latency, memory usage. An engineer reads the dashboard and decides what to do. The system itself is oblivious.

The difference between external monitoring and a self-model is the difference between a patient and a doctor. A patient can say “my chest hurts”. That’s a self-model: internal access to one’s own state, informing one’s own decisions. A doctor has external monitoring: instruments, tests, charts. Both produce useful information. But only the patient’s information is available to the patient for autonomous action.

If you want a system that manages itself, it must be the patient, not the doctor. It must have internal access to its own state. External monitoring creates a dependency: the system needs someone else to read the dashboard and act on it. A self-model makes that dependency unnecessary.

Proprioception: The Body’s Self-Model

The closest biological analogy is proprioception, the sense that tells you where your body parts are without looking. Close your eyes. Raise your hand. You know where it is. That knowledge comes from internal sensors, stretch receptors in muscles, pressure sensors in joints, feeding continuous information to your brain about your body’s configuration.

Proprioception is not a complete model of your body. It doesn’t represent your liver or your DNA. It represents the operationally relevant features: position, velocity, tension, balance. It is lossy. It is continuous. It is used for real-time decision making.

An aware system’s self-model is computational proprioception. It senses the system’s internal configuration, knowledge size, performance trends, structural health, and makes that information available for the system to act on. When the system decides to grow its knowledge structure, or prune dead patterns, or shift its focus, that decision is informed by M.

The Relationship Between Axiom 1 and Axiom 2

Axiom 1 (Operational Closure) said: the system produces and maintains all its own components. Axiom 2 adds: one of those components is a representation of the whole.

This creates a specific kind of circularity. The system maintains K. M lives inside K. M represents the system, including K. So K contains a representation of itself. This is not infinite recursion because M is compressed: it represents features of K, not K itself. The map is not the territory.

But the circularity is real, and it is productive. The system can use M to decide how to modify K, and changes to K update M, which informs further decisions. This is a feedback loop, the kind that makes self-governance possible.

Destroy M, and the system still functions, in the same way that you still function with your eyes closed. But it loses the ability to make informed decisions about itself. It becomes reactive rather than reflective. It can still learn, but it can no longer learn about its own learning.

The Hard Part

Building a self-model is easy. Building a useful one is hard.

The challenge is calibration. A self-model that always says “I’m performing well” is useless. A self-model that accurately tracks uncertainty, that knows what it knows and what it doesn’t, that detects degradation before it becomes failure, that is valuable.

In machine learning terms: the self-model must be well-calibrated. Its assessment of the system’s performance must correlate with actual performance. Its assessment of uncertainty must correlate with actual error rates. This is hard for the same reason that uncertainty quantification is hard in any ML system. But it is not optional. An uncalibrated self-model is worse than no self-model at all, because it provides false confidence.

In practice, we found that calibration does not require a complex mechanism. It requires feedback. The system records whether its past decisions helped or hurt. When M says “you should grow” and the system adds a layer, it tracks what happened next. Did accuracy improve? Record: growth helped. Did it plateau or decline? Record: growth failed. The ratio of successes to failures becomes a confidence score that adjusts future decisions. If growth has failed repeatedly, M becomes more cautious, it waits longer, demands stronger evidence of plateau before recommending growth again.

This is not evolution. It is something simpler: a system that remembers the consequences of its own decisions and adjusts accordingly. The self-model calibrates itself through the same feedback loop it uses for everything else.

What This Is Not

The self-model is not consciousness. It is not experience. It is not the “hard problem”. It is a functional component: a compressed representation of the system’s own state, used for self-governance. Whether this constitutes any form of inner experience is a question AWARE does not attempt to answer, and doesn’t need to.

The self-model is also not introspection in the human sense. A human can reflect on their own thoughts, construct narratives about their own motivations, wonder why they feel the way they feel. An aware system’s self-model is simpler: it tracks structure, performance, and capacity. It is more like proprioception than like philosophy. Sufficient for self-management. Silent about meaning.

What We’ve Proven

When this axiom was first written, the self-model was a theoretical requirement. It is now a working component. Here is what the system actually does:

Autonomous depth. The system starts with a single layer. As it trains, M tracks validation accuracy, loss trends, and epochs since the last structural change. When M detects a plateau, flat accuracy over sufficient epochs, it recommends growth. The system adds a layer without any external trigger. No human reads a dashboard and decides. The system decides.

Growth confidence. The system records the outcome of every growth decision. After growing, it monitors whether accuracy improved. Over time, this builds a success ratio that adjusts future decisions. A system that has grown successfully is willing to grow again. A system that has grown and seen no benefit becomes cautious. This is calibrated self-governance from internal state alone.

Autonomous lifecycle. The system manages its own training sessions. Data arrives asynchronously. The system trains until M says it has plateaued and exhausted its growth options, then stops. It wakes when new data arrives. No epoch limits, no external scheduler. The self-model is the scheduler.

The numbers. Starting from a single layer and random embeddings, the system autonomously grew to multiple layers and reached 25%+ accuracy on unseen data with less than 1 percentage point generalization gap. The stopping decision, the growth decisions, and the training duration were all determined by M. The only human decision was to feed it text.

The self-model is not the most visible component. It does not directly process inputs or produce outputs. But without it, none of the autonomous behavior above would exist. The system would need an engineer to watch a dashboard and decide when to grow, when to stop, when to add capacity. M is what makes the engineer unnecessary.

What Comes Next

Axioms 1 and 2 together give us a system that maintains itself (closure) and knows its own state (self-model). But a system that only maintains itself is just sophisticated homeostasis. It survives, but it doesn’t go anywhere.

Axiom 3 introduces what makes a self-maintaining, self-knowing system into something that acts: a relationship with the outside world that goes beyond passive input and output.

AWARE is a research project exploring self-evolving intelligence. The axioms are implemented and running. The self-model drives autonomous growth decisions in production.

Next post: Axiom 3 — how a self-maintaining system develops a meaningful relationship with its environment.