Letting AI Look Itself in the Mirror

I built and tested a system that appears to reflect on itself. Of course it doesn't, but it revealed a more profound research question

Some time ago, I was talking with my eldest son about the future of technology. At some point, the conversation drifted toward consciousness and the inevitable question:

What is consciousness?

We reached for the usual anchors. The idea that consciousness is, at least in part, what it feels like to be a person. That there are degrees of it, not a binary threshold. Certain animals are self-aware and exhibit forms of consciousness.

Can robots be conscious?

Science fiction has no shortage of answers. From Blade Runner, where replicants blur the boundary between programmed behavior and lived experience, to Ex Machina, where self-awareness becomes indistinguishable from manipulation, to Her, which explores consciousness without a body, the genre tends to assume that once behavior crosses a certain threshold, consciousness follows.

However, if we ground the view in science, the picture becomes more complex and interesting. One organization that tackled aspects of this question is the Geneva Science and Diplomacy Anticipator. It frames consciousness research as a layered problem, spanning proxy measurement, modeling, and ultimately governance. What becomes clear in that framing is that we are likely to encounter systems that behave as if they are conscious well before we can say what consciousness actually is.

Despite the complexity, I explained, there's a very simple test to evaluate consciousness: looking in the mirror.

Can a robot recognize itself in the mirror?

That's one heck of a question! In principle, that kind of test seems straightforward. You present a system with itself and observe whether something like self-recognition emerges.

Hence, what would it look like to build a system that is explicitly asked to “look at itself”? And more importantly, what would we actually be observing if it appeared to succeed? That question led to the experiment.

I developed the code, ran the tests, and analyzed the experimental traces around a simple but revealing setup: an iterative “mirror” loop in which a system repeatedly generates an emotionally modified self-image, describes the state it appears to be in, produces a brief introspective monologue, and then moves to a next plausible emotional condition. Over time, this creates a running trajectory of apparent self-relation.

The early result is both encouraging and clarifying. The system remains stable, even in the presence of sounds and contextual variation. But that stability does not appear to come from any genuine introspective mechanism. It comes from the structure of the loop itself: a carefully assembled pipeline that is very good at preserving narrative continuity, even when no actual inward process has been triggered.

That is the real significance of the first tests. They do not show the emergence of introspection. They show how easily the appearance of introspection can be engineered, and why distinguishing between the two is the real research task.

The architecture behind the appearance

The system I developed follows a clean loop: generate an emotional state from an image, produce a short reflective monologue, infer the next state, and update a running representation of “self.” Over multiple iterations, this produces a trajectory that feels internally consistent. It looks like a mind stabilizing around an attractor.

But the key detail is where that “state” actually comes from.

The system does not maintain a latent internal process that is then expressed outward. Instead, it reconstructs its state after the fact from outputs:

• emotion labels inferred from generated images
• intensity mapped to arousal
• predefined mappings to valence and dominance
• lexical signals (e.g., first-person usage) as proxies for self-focus

Even the notion of a “mirror score” —a signal that appears to capture self-referential depth— is partially constructed from simple accumulators and keyword presence. The result is a system that behaves as if it has continuity because continuity is structurally enforced. This distinction matters: The system is not discovering its state, it is assembling a state representation from its own narration.

Why stability emerges

The most striking observation from the first runs is that the system remains stable —even when exposed to different auditory conditions— and that no meaningful introspective shift is triggered.

At first glance, this is surprising. If the system is sensitive to context, one would expect sounds —especially those associated with tension, noise, or human presence— to perturb its trajectory. But the stability is not incidental, it is largely architectural: The auditory layer, while rich in design, is not directly coupled to the system’s state update. It exists primarily as contextual input (something the model may or may not incorporate into its generated response). There is no enforced causal pathway from stimulus to state.

At the same time, the state update itself is damped: the previous state is blended forward, emotional transitions are constrained, and the scoring functions bias toward accumulation rather than volatility. Under these conditions, the system does what well-designed systems often do: it converges toward a stable regime. The appearance of resilience is, in part, a property of the scaffolding.

What is actually being measured

Once you step back from the surface narrative, the system is not measuring introspection in a strong sense. It is measuring something more precise and more limited:

the ability of a generative system to maintain a coherent self-description across iterative transformations.

This is closer to structured self-consistency than to introspection. The monologue reads as reflective. The trajectory looks intentional. But both are downstream of the same generative process, constrained by heuristics that ensure smoothness. There is no independent signal that can contradict the narration. No internal representation that resists the story being told: The system cannot surprise itself.

The role of sound — and its absence

The addition of auditory stimuli is conceptually important. It introduces the idea of external perturbation, of a world acting on the system. But in its current form, sound is descriptive rather than causal: It shapes the prompt, not the state. It influences the narrative only if the model chooses to incorporate it. And because the rest of the system is biased toward continuity, the default outcome is absorption without disruption.

This leads to a subtle but important point: A system that remains stable under perturbation is only interesting if the perturbation is real.

Here, the perturbation is optional. And so stability is expected.

The deeper limitation

The limitation is not technical, it is conceptual. The system collapses three roles into one:

1. Generator: produces the monologue
2. Interpreter: infers emotional state
3. Evaluator: updates the system state

Because all three are derived from the same output stream, there is no separation between experience and description. Introspection, in any meaningful sense, requires that separation. It requires the possibility that what is observed differs from what is said. That there is a layer of internal structure that cannot be fully reduced to narration. Here, narration is the structure.

A stronger approach

Where this leads

The next phase is not about adding more modalities or richer prompts. It is about introducing structural independence.

A few directions become unavoidable:

• Make perturbations causal External inputs (e.g., sound, context, events) must directly alter the state, not just the prompt
• Decouple state from narration The system should maintain a latent representation that is not reconstructed from its own text
• Introduce disagreement Multiple evaluators, or a blinded assessment layer, should be able to contradict the generated monologue
• Test for divergence Stability should be challenged, not assumed, through controlled perturbations and ablation of smoothing mechanisms

These are not simple improvements.

A different way to read the result

The current system does something valuable, but not what it first appears to do. It shows how easily coherence can be constructed. How quickly a loop can begin to feel like a self. How stable a system becomes when continuity is engineered into its core. In that sense, the result is less about the emergence of introspection and more about the conditions under which introspection can be convincingly simulated. The question that must be asked before “is the system becoming self-aware?” is still:

**What level of structural independence is required before self-description stops being a sufficient proxy for self-understanding?**

That boundary is where this work becomes interesting.