Modelling the Self: Object-Oriented Cognition Applied Reflexively

ThisThis series describes an architecture that exhibits structural and functional signatures several theories associate with consciousness. It does not claim that building those signatures produces consciousness itself. Searle's distinction between weak and strong AI names this precisely: weak AI treats a program as a model or tool for studying a mental process; strong AI claims the program literally is that process¹. This series makes the weak claim throughout. An analogue, not an instance.

Objects get boundaries and behaviour together

Spelke'sSpelke's research on infant perception found that object segmentation is not neutral geometry. Infants divide a cluttered visual scene into objects using physical-behaviour principles: units that move as connected wholes, keep their shape under motion, interact with each other only on contact². Boundary detection and behavioural expectation happen as one act, not two. A cognitive system's Model stage should work the same way: identifying an object in the perceived environment and attaching an expectation of what that kind of thing does are the same operation, not sequential ones.

This is not the same claim as Gibson's affordances. An affordance is what an object offers a specific perceiver for action — a chair affords sitting³. Spelke's principle is what an object does on its own, independent of any perceiver's use for it. Both matter. They answer different questions.

Shared traits through composition, not rigid hierarchy

ParsimonyParsimony requires that identified objects share traits rather than each carrying a full independent description. Rosch's prototype theory found that human categories are organised around family resemblance and overlapping features, not necessary-and-sufficient defining conditions inherited down a strict hierarchy⁴. A category member shares some traits with other members without sharing all of them, and no single trait is required of every member. This is composition: an object has a bundle of traits drawn from overlapping sources, rather than inheriting a fixed set from one parent category.

Software engineering reached the same conclusion independently. Composition over inheritance is a standard design principle in object-oriented programming, for closely related reasons: a rigid inheritance hierarchy breaks under edge cases a flexible trait bundle absorbs without modification. A cognitive system modelling external objects should default to composition for the same reason both fields converged on it — shared traits without a rigid hierarchy tolerate the actual variation an environment produces.

The self as one more object

IfIf external objects get boundaries, behavioural expectations, and composed traits, the same machinery can model the system's own body and capabilities. This is not a convenience. Bongard, Zykov and Lipson built a four-legged robot that infers a model of its own structure from the relationship between its actuator commands and its sensor readings, uses that self-model to generate walking, and rebuilds the self-model after a leg is removed — producing a new gait from the updated model rather than failing⁵. The resilience comes specifically from treating the self as a genuine object inside the same modelling framework used for everything else. Damage to the self updates the same kind of representation that damage to an external object would.

Wolpert and Kawato's account of human motor control makes the composition point directly for self-models. The brain is proposed to hold multiple paired forward (predictive) and inverse (controller) models rather than one monolithic self-model, combined through weighted responsibility signals that shift which pair dominates as context changes⁶. Composition, applied to the self specifically, for the same reason it applies to external objects: no single rigid model survives every situation.

Gallese and Goldman's simulation theory gives a reason the same machinery should model both self and other, rather than two separate systems built in parallel. Understanding another agent's action and generating one's own action are proposed to draw on shared neural machinery — modelling another agent may be running one's own action-generation system in a different mode⁷. If self-modelling and other-modelling already share machinery in biological cognition, building them as one shared mechanism rather than two separate ones is the architecture that matches the evidence, not an arbitrary simplification.

A self-model that switches at run time

TheThe cognitive cycle already includes an edge from Abstraction back into Perception, carrying schema-driven expectation: general knowledge shapes what gets perceived before any explicit reasoning runs. Apply that same edge to a self-model instead of a general external-object abstraction, and two distinct operating modes become available, switchable at run time rather than fixed at design time.

Opaque mode: the self-model sits as an explicit, labelled entry inside Representation, consulted by Reason/Plan the way any other modelled object's expected behaviour is consulted. Reasoning has direct, inspectable access to the fact that this is a model of the system itself.

Transparent mode: the self-model's output feeds directly back into Perception, upstream of anywhere Reason/Plan could inspect it. The influence on behaviour is real, but nothing downstream ever receives it labelled as coming from a self-model at all. It arrives already folded into what the system perceives.

This maps onto a real distinction in the philosophy of mind literature, developed for entirely different reasons — that mapping and its consequences are the subject of the next page in this series. The point at this stage is architectural: the switch between the two modes is a genuine design choice a real system could make, and could in principle make differently from one moment to the next, not a fixed property of having a self-model at all.

Where this connects

• Sense, Model, Think, Predict, Imagine, Act — the cognitive cycle this page extends, including the schema-feedback edge repurposed above.
• Object-Oriented Programming (this site's OOP track) — composition over inheritance, developed independently in software design for closely related reasons.
• Does a Self-Model Get You Anywhere Near an Analogue of Consciousness? (next in this series) — what the transparent/opaque distinction maps onto in the philosophy of mind literature.

References