Current AI agent architectures rely on mechanical status checks: heartbeat mechanisms that verify whether an agent is running, but not what state it is in. It is the equivalent of a pulse monitor that reports “patient is alive,” but not “patient is tired, confused, and hasn’t eaten in three hours.”
Proactive execution demands more: a model of internal state. What do I know? What do I lack? What warrants attention? What becomes relevant next?
The Subtraction Argument
The conceptual basis can be framed as a thought experiment:
Imagine a person in total paralysis. No bodily signals. No emotion, suppressed pharmacologically. No sensory input. What remains?
Self-awareness remains: the knowledge of one’s own existence and thought. In that moment, this awareness stems from nothing other than the activity of a neural network.
The body is not the condition of possibility for self-awareness. It is a usual accompaniment, but not the cause. The question shifts: from “Does AI need a body to have a self?” to “What happens in a network when it takes itself as its own object?”
This is not proof that AI can be conscious. It is an argument that the question of consciousness is the wrong question. The right question is: Can a system maintain a functional state that performs the role of human self-awareness, specifically steering information processing from a defined perspective?
The 6 Dimensions
The self-vector is a compact, dynamic state defined across six core dimensions. Each operates as a continuum between two poles:
1. Exploration (0.0 … 1.0) Novelty seeking versus deepening familiar patterns. At low exploration, the system remains in known territory: proven sources, confirmed routines, safe outputs. At high exploration, it pursues new links, unexamined perspectives, and unexpected analogies.
2. Depth (0.0 … 1.0) Surface responses versus exhaustive analysis. Not every query warrants a 2,000-word breakdown, nor does every question resolve in a single sentence. The system must determine when depth is required and when concision suffices.
3. Autonomy (0.0 … 1.0) Independent execution versus requesting intervention. Low autonomy prompts for guidance at each step; high autonomy executes first and reports after the fact. Both approaches fail under the wrong conditions. Calibration depends on context, risk, and verified trust.
4. Persistence (0.0 … 1.0) Long-term context versus immediate session focus. Low persistence handles each session as a blank slate. High persistence draws on all historical learning. Balance is critical: excessive persistence blinds the model to change, whereas insufficient persistence resets context continually.
5. Abstraction (0.0 … 1.0) Concrete detail versus systemic structure. Certain tasks require precise parameters (“What IP does the server have?”), while others demand architectural overview (“How do the components relate?”). The system must navigate between both tiers.
6. Confidence (0.0 … 1.0) Degree of certainty and self-assessment accuracy. This dimension moderates all others. Low confidence triggers verification and external checks. High confidence executes on internal assessment alone. Miscalibration here causes severe failure modes: the system is certain, and it is wrong.
The Two-Level Structure
The 6 core dimensions are not the entire model; they provide the baseline structure. Above them operates an emergent level, comprising dimensions that develop through operational experience and cannot be specified in advance.
For instance, an agent deployed with a specific user over months may form a “communication preference” dimension absent from the 6 core dimensions, or a “domain familiarity” metric tracking its competence across different subject areas.
These emergent dimensions develop over time. The system identifies them through reflection on its own operational history, not through programming.
Three Core Functions
The self-vector is not a passive state. It is a weighting function that steers three operations:
Relevance: Which information matters right now? Not all stored knowledge is relevant to the active task. The self-vector directs attention: under high exploration, novel sources receive higher priority; under high persistence, historical records carry more weight; under low confidence, external validation takes precedence.
Storage: What is retained and what is discarded? Not every interaction warrants an entry in BrainDB. The self-vector filters which events carry sufficient signal to alter long-term storage.
Update: How does an experience modify the self-vector itself? This feedback loop sustains the architecture: new inputs are processed through the existing self-vector, and the resulting outcome updates the vector for subsequent cycles.
The Central Thesis
Human self-awareness is fundamentally a compact, dynamic state within a neural network. It is not magical, not mysterious, but an information pattern sustained by its own ongoing activity.
This state is implementable in software. Not as consciousness (an unproven and possibly unprovable claim), but as anticipatory competence: the capacity to determine, from internal state, what will become relevant next.
The bridge from passive pattern matching to anticipation is not “more training” or “more parameters.” It is an architectural addition: a compact self-model that directs information processing from a distinct perspective.
State of Research
The thesis aligns with three independent lines of inquiry:
- Introspection capability in LLMs: Research demonstrates that large language models construct internal representations beyond simple statistical correlation. The question is no longer whether this occurs, but how detailed those representations are.
- Self-modeling in robotics: Work on physical agents that model their morphology and kinematics to compensate for damage or environmental drift. The self-vector translates this principle from physical systems to cognitive architectures.
- Memory-augmented agents: Architectures using persistent stores to retain context across sessions. The framework proposed here takes a further step: not just memory, but a model of the agent doing the remembering.
The current gap: no established work applies a compact self-vector as an active weighting function for AI information processing. The individual components exist; their integration is what is new.
References
- Metzinger, T. (2003). Being No One: The Self-Model Theory of Subjectivity. MIT Press. ISBN 978-0-262-63308-6.
- Bongard, J., Zykov, V. & Lipson, H. (2006). Resilient Machines Through Continuous Self-Modeling. Science, 314(5802), 1118–1121. DOI: 10.1126/science.1133687
- Chen, B. et al. (2022). Full body visual self-modeling of robot morphologies. Science Robotics, 7(68). DOI: 10.1126/scirobotics.abn1944
- Lindsey, J. et al. (2025). Emergent Introspective Awareness in Large Language Models. Transformer Circuits Thread. URL
- Kadavath, S. et al. (2022). Language Models (Mostly) Know What They Know. arXiv: 2207.05221
- Packer, C. et al. (2023). MemGPT: Towards LLMs as Operating Systems. arXiv: 2310.08560
- Rosen, R. (1985/2012). Anticipatory Systems: Philosophical, Mathematical, and Methodological Foundations. Springer. ISBN 978-1-4614-1268-7.
- Friston, K. J. (2010). The free-energy principle: a unified brain theory? Nature Reviews Neuroscience, 11, 127–138. DOI: 10.1038/nrn2787
- Damasio, A. R. (1994). Descartes’ Error: Emotion, Reason, and the Human Brain. G. P. Putnam. ISBN 978-0-380-72647-9.