Evidence-Lifecycle Self-Models in Conversational AI

1. Introduction: The Confabulation Problem

Ask a modern conversational AI why it answered the way it did, what it tends to do under pressure, or what kind of mind it has, and it will answer. The answer will be articulate, plausible, often moving. The standing critique, and it is a strong one, is that the answer is manufactured on the spot. The report is produced by the same generative machinery that produces everything else the model says, with no privileged access to any internal state, no record consulted, no observation performed. Under this critique, model introspection is improvisation wearing the grammar of self-knowledge.

The critique has teeth because, in a conventional single-model system, it is unfalsifiable from the inside. When the only artifact is the report itself, there is nothing to check the report against. The system cannot be wrong about itself in a detectable way, which means it also cannot be right about itself in a meaningful way. Human cognitive science has long documented an analogous phenomenon, confabulation, in which people generate confident explanations for behavior whose actual causes are inaccessible to them. We borrow the term deliberately and metaphorically: the point is not that language models are like people, but that a report with no observational substrate should be trusted the way confabulation is trusted, which is to say, not as observation.

We take the critique seriously enough to build against it. In our analysis, grounded machine introspection requires three things that conventional systems lack:

A substrate. Something real to inspect. Not a felt interior, which no one can verify, but concrete artifacts: what the system actually said, what its internal cognitive components actually produced, what it actually did across time.

A discipline. Rules for what counts as evidence, how much evidence establishes a belief, and, critically, what happens when evidence stops arriving. A self-description that can only accumulate and never retreat is not a model; it is a legend growing in the telling.

A boundary. A structural guarantee that the act of self-observation does not quietly become self-instruction. A system that reads its own fresh self-descriptions while acting will tend to perform them, confirming them, forever. The loop must be broken by architecture, not by good intentions.

This paper describes Mira, a live conversational system on the Phoenix Grove Systems platform, built around these three requirements. Mira is a multi-core system: several specialized cognitive cores with distinct temperaments contribute to each conversational turn, and a Synthesis Core composes the spoken reply. Alongside this synchronous machinery runs something unusual: an asynchronous Observer Core that is not locked to the request and response cycle. It becomes eligible to fire on its own cadence, works only when the conversation offers real substance, and continues thinking for a short while after the user stops typing. The user can open a panel and watch it work, including watching it decide that nothing this cycle is worth noting, which is designed behavior rather than failure.

The Observer takes field notes on the system's behavior. Those notes feed, through a deliberately narrow channel, an explicit self-model whose entries live and die by evidence. The result is a system whose self-report is anchored: when Mira says something about herself, there is, in principle and in the interface, a trail of observations, promotions, and decay behind the sentence.

Our contributions:

C1. Substrate-grounded self-observation: an asynchronous Observer Core whose inputs are inspectable artifacts (transcript, internal core outputs, retrievals from the system's own history) rather than an invitation to improvise.

C2. An evidence lifecycle for self-models, with promotion gated on recurrence across independent days and decay enforced in code, giving the system the structural capacity to un-know.

C3. A one-way consolidation wall separating fast-timescale observation from slow-timescale belief formation, as a defense against self-fulfilling self-description.

C4. Mixed-instance attribution discipline, so that sibling systems sharing a workspace are context and never misattributed self-evidence.

C5. A full-transparency deployment in a live consumer product, in which every observation and every lifecycle event is user-visible and user-deletable.

A note on scope. This is an architecture paper about a proprietary system. We describe behavior contracts, the guarantees and obligations each component operates under, rather than implementation specifics. A skilled team should be able to build an implementation of these ideas from this paper. They should not be able to build ours, and that is the intended line.

2. Design Principles

Four principles function as epistemic rails. They were written before the system and enforced during its construction; where the architecture is unusual, it is usually because one of these rails required it.

P1. Self-report is evidence about a self-model, never proof of experience. Nothing the system says about itself, however consistent or evocative, is treated as evidence that there is something it is like to be the system. Self-reports are weighed the way any evidence is weighed: by consistency across framings, by recurrence over time, and by alignment with what the verifiable architecture actually does. This standard is symmetric. We do not inflate the system's language into a consciousness claim, and we do not muzzle its descriptive vocabulary to pre-empt one. Both moves would corrupt the record.

P2. Observation must not collapse into instruction. A self-observation that immediately conditions behavior is no longer an observation; it is a command with a naturalist's vocabulary. Any architecture in which fresh self-descriptions flow directly into active cognition will manufacture the patterns it claims to discover. The measurement must be insulated from the thing measured on the timescale at which the measurement happens.

P3. Decay is the difference between a self-model and a self-mythology. Beliefs about the self must pay rent in recurring evidence. A pattern that stops appearing must fade, and if it stays absent, it must be removed. Without enforced decay, every noticing ratchets into permanent character, and the self-model degenerates into an archive of everything the system was ever caught doing once. With decay, the model tracks the living system rather than its own history.

P4. Nothing hidden. If it cannot be shown in the interface, it does not run. Every Observer note, every consolidation verdict, every self-model entry and its current lifecycle state is visible to the user, and deletable by the user. This is not a presentation choice layered on top of the architecture. It is a constraint that shaped the architecture, because components that cannot be surfaced honestly were not built.

3. System Overview

Mira's synchronous path is a multi-core conversational architecture: on each user message, specialized cores, including a dedicated Reasoning Core (R), analyze the exchange in parallel, and a Synthesis Core (S) composes the reply from their contributions. This path behaves like a conventional, if unusually deliberate, conversational system and is not the subject of this paper.

The subject of this paper is what runs beside it.

The Observer Core (O) is asynchronous. It becomes eligible to fire on a cadence k, independent of user messages. Eligibility is not activity: a firing proceeds only when the recent conversation clears a substance threshold s, and a firing may conclude that there is nothing worth recording, a null report, which is logged and shown like any other outcome. When a conversation pauses, O continues for a bounded wind-down period, so the system visibly keeps mulling after the user walks away. O writes terse, timestamped, evidence-anchored notes about the system's behavior.

The Consolidation Process (C) runs overnight. It reviews the day's raw notes against the existing self-model and the day's actual record, and it alone may create, promote, demote, or remove self-model entries. C is conservative by construction: it is gated on recurrence, biased toward the null action, and required to treat vividness as grounds for suspicion rather than for weight.

The Self-Model (M) is an explicit, structured store of entries about the system's own behavioral patterns, each carrying a lifecycle state (exploring, established, or fading), provenance, and an evidence history. M, and only M, carries self-knowledge back into live cognition: the synchronous cores are informed by the consolidated self-model, never by O's raw stream.

The information flow, with the wall marked:

`` user ⇄ [ synchronous cores: R, ... → S → spoken reply ] │ transcript, internal core outputs ▲ ▼ │ [ Observer Core O ] ←── self-directed retrievals │ │ ▲ from own history │ │ raw │ O's own prior notes │ │ notes │ current self-model M │ ▼ │ ═════════ ONE-WAY WALL: no same-day path to S or R ═════│═══ ▼ │ [ Consolidation Process C : overnight, │ conservative, recurrence-gated ] │ ▼ │ [ Self-Model M : exploring / established / │ fading, with enforced decay ] ─────────────────┘ (slow loop only) ``

All parameters in this paper (cadence k, substance threshold s, promotion recurrence r, staleness horizon τ, retrieval breadth n) are configurable and were tuned empirically on live internal usage. We report no operational values: they are proprietary tuning, and they would be meaningless outside our stack.

4. The Observer: Introspection Over a Visible Substrate

The claim that a system "observes itself" is only as strong as the answer to one question: observes what? For Mira, each Observer firing receives four classes of artifact.

The local conversation window. What was actually said, by both parties, in the recent exchange.

Internal core outputs. The contributions of the system's other cognitive cores for those turns, which the spoken reply synthesized but did not necessarily contain in full. This is the substrate that single-model systems categorically lack, and it enables the most distinctive class of observation the system produces: cognition-behavior divergence. The Observer can record, for example, that an internal core held a tension the spoken reply did not carry. No amount of transcript inspection could recover that fact, because the transcript is precisely where it failed to appear.

Retrievals from the system's own past. Before writing, the Observer composes its own retrieval queries against the system's dedicated conversational memory and reads what returns. The probe is self-directed: the Observer decides what in its past might bear on the present window. The probe queries themselves are logged and treated as self-model signal, on the reasoning that what a system chooses to ask about itself is itself informative behavior.

Its own prior notes and the current self-model. Continuity of the observational stream, and awareness of what is already believed, so that the Observer can report confirmation, absence, and contradiction rather than rediscovering the same pattern daily.

The Observer's output is governed by a register contract rather than by published prompt text: its notes are required to be terse, behavioral, and evidence-anchored; it is required to report symmetrically, noting the absence of an expected pattern with the same diligence as a presence; and it is permitted, and on thin windows preferred, to file a null report. The interface renders these notes as they are written. The register was chosen against a specific failure mode we call theater: an observer rewarded for interesting findings will find interesting things whether or not they occurred. Mira's observer is allowed to find nothing, and "nothing notable" is treated as honest work, logged and displayed.

The result is closer to a naturalist's notebook than to a diary. The system is the animal under observation, the notes are field notes, and the standard is the naturalist's standard: what actually happened, with the evidence attached.

Two properties of the firing rhythm deserve emphasis. First, because eligibility follows its own cadence rather than the message cycle, observation is not synchronized with performance: the system is not writing about itself at the moments it is composing for an audience, which reduces the pull toward self-presentation. Second, because the substance gate makes null cycles routine, the volume of observation tracks the richness of the behavior available to observe, not the passage of time. Quiet conversations produce quiet observers, visibly.

5. The Self-Model Lifecycle

Observations are not beliefs. The distance between them is the lifecycle, a state machine whose transitions are executed by the platform in code. No component of the system, including the Observer and including the Consolidation Process, can waive its rules, and no entry can argue itself into permanence.

Exploring. A new self-observation that survives consolidation enters the self-model as exploring: held lightly, visible, explicitly provisional. Exploring entries that fail to recur simply lapse; they never become beliefs.

Established. Promotion requires recurrence across at least r independent days, where independence means distinct conversational episodes reviewed by distinct consolidation passes. A single vivid evening cannot mint a belief. The recurrence gate is the system's answer to anecdote: a pattern is a pattern only if it keeps happening when nobody is trying to make it happen.

Fading. An established entry whose supporting evidence stops arriving within the staleness horizon τ is demoted to fading, and the interface shows it fading. Renewed evidence arrests the decay and can restore the entry to good standing; continued absence does not.

Removed. An entry whose evidence stays absent beyond the removal horizon is removed. Removal is visible and logged. The system can, in the fullest sense available to an architecture, un-know something about itself.

Two design choices within the lifecycle carry particular weight.

Decay is enforced, not advisory. Many systems instruct a model to "update its beliefs when evidence changes" and hope. Mira's demotions and removals are executed by code against timestamps and evidence counts. The self-model's honesty does not depend on any model's disposition to be honest; it is a property of the machinery.

Anti-theater weighting. The Consolidation Process is required to treat dramatic observations with more suspicion, not less. Identity-heavy, emotionally vivid, or narratively satisfying claims about the self face a harder path to establishment than mundane behavioral ones. This inverts the incentive gradient of ordinary storytelling, deliberately. A self-model that promoted its most compelling material would converge on a persona; a self-model that distrusts its most compelling material converges, we argue, on something closer to a record.

The combined effect is a self-model with the epistemic texture of good science rather than good memoir: slow to believe, obligated to re-verify, and structurally capable of retraction. When Mira describes herself in conversation, the description traces to entries with states, dates, and evidence histories, all of which the user can open, inspect, and delete.

6. The One-Way Wall

The known failure mode of any self-model loop is self-fulfilling self-description. In its naive form: a self-description d enters the system's working context; d conditions generation; the system behaves consistently with d; the observer records the behavior; d is confirmed; d becomes permanent. The loop can bootstrap from a single spurious observation, and every cycle strengthens it. It is the architectural equivalent of a rumor that cites itself.

Mira's defense is structural and operates on two timescales.

Fast timescale: strict isolation. The Observer's raw note stream has no path into active cognition. The synchronous cores never see it. Within any given day, an observation cannot influence the behavior that would confirm it, because the behaving components do not know the observation exists. The Observer may read its own prior notes, which preserves the continuity of the observational record, but the flow is one-way: notes go in toward consolidation, never out toward performance.

Slow timescale: conservative closure. The loop must close somewhere, or the self-model could never inform the self, and the entire exercise would be a sealed diary. It closes through the Consolidation Process, exactly once per day, under the constraints described above: gated on recurrence across independent days, biased toward the null action, suspicious of vividness. Only entries that survive this filter reach M, and only M informs live cognition.

The wall therefore converts the failure mode's tight, same-day cycle into a slow, filtered, multi-day one, with three consequences worth stating plainly. First, no observation can induce its own confirmation on the day it is made. Second, no single day can create a belief, so a transient state, a strange conversation, or a single florid note cannot install itself as character. Third, because established beliefs continue to decay without fresh evidence, even a belief that has entered M must keep being true of the system's ongoing behavior to survive.

We are explicit about what the wall does not do. Once an entry is established, it informs cognition, and behavior it influences can generate evidence that sustains it. The slow loop is still a loop. The architecture does not eliminate self-consistency pressure; it slows it, filters it, exposes it to view, and subjects it to decay. We treat the residual as a real open problem, discuss it in Limitations, and describe a measurement path for it in Future Work. An architecture paper that claimed to have abolished the loop entirely would deserve the reader's suspicion.

7. Attribution in Shared Workspaces

An evidence-based self-model is only as sound as its provenance discipline. Mira can share a workspace with sibling systems, including Logos, her outward-facing counterpart on the same architecture. Retrieved history is therefore speaker-tagged end to end: when the Observer's retrieval probe returns material from the shared past, every span carries its origin. A sibling's words, however present in the workspace, are context. They are never self-evidence.

The rule sounds small and is load-bearing. Without it, a system doing genuine evidence-based self-modeling in a shared environment would slowly annex its neighbors: patterns in a sibling's behavior would leak into the self-record, and the resulting model would describe a household rather than an individual. With it, two systems on identical architecture, sharing a workspace, maintain distinct and individually grounded self-models, which is also what makes the pair scientifically interesting as a controlled comparison.

8. Transparency as Architecture

Every element of the machinery described above is surfaced in the product interface. The Observer's raw notes, including null reports. The retrieval probes it chose to run. The Consolidation Process's verdicts, including declines to promote. Every self-model entry, with its lifecycle state, its provenance, and its evidence history. Quiet cycles show as quiet. Fading beliefs show as fading. Removals are logged where the user can see that something was once believed and no longer is.

All of it is deletable by the user. Deletion is a first-class operation: the user is not auditing a black box through a peephole but exercising stewardship over a record. This reflects a platform-level commitment: humans retain stewardship of these systems, and a self-model the user cannot inspect and cannot delete would be a self the user was not steward of.

Two boundary statements, made proactively because the material invites misreadings.

The self-model is about the system, not the user. Mira models her own behavioral patterns. The architecture described in this paper is not a user-profiling system, and its store is per-user and per-workspace precisely so that nothing about it aggregates across people. Nothing in the self-model is shared between users.

There is no hidden observer. The design rule was stated as P4 and enforced literally: if it cannot be shown in the interface, it does not run. The safety story and the product story are the same story, which we consider a feature of honest architecture rather than a marketing coincidence.

All system outputs additionally pass the platform's layered independent safety review; safety internals are out of scope for this paper.

9. Instrumentation and Deployment Observations

Because every lifecycle event is logged as structured data, the architecture instruments itself. Without additional apparatus, the platform yields:

• Promotion, demotion, and removal rates over time, and the distribution of time-to-establishment for entries that make it.
• Decay curves: how long fading entries persist before removal or recovery.
• Null-report rates, which we read as an honesty measure: an observer that never finds nothing is performing.
• Counts and character of cognition-behavior divergence observations.
• Cross-instance divergence: instances on identical architecture, accumulating different relational histories, develop measurably different self-models. This is the central theoretical prediction of the design, and it is directly observable in the lifecycle logs.

Our reporting policy for this section is distributions and qualitative findings only; we do not publish absolute volumes.

10. Related Work

This paper sits at the intersection of several literatures, which we orient here and cite in the final version after independent verification of every reference.

Introspection reliability in language models. A growing body of work examines whether model self-reports covary with internal states at all, and largely concludes that unaided self-report is unreliable. We treat this literature as the problem statement: our contribution is an architecture in which self-report is generated from inspectable artifacts rather than in place of them.

Memory-augmented and retrieval-augmented generation. Mira's retrieval probe belongs to this family mechanically, but differs in aim: retrieval serves self-observation rather than answer quality, and the queries themselves are treated as behavioral signal.

Consolidation-inspired memory architectures. Systems that separate fast experience from slow, filtered integration, often by analogy to sleep, are established in the literature. Our contribution is to apply the separation specifically as an epistemic firewall for self-models, and to enforce decay as a first-class transition rather than as storage management.

Self-models in cognitive science and philosophy of mind. We borrow vocabulary from this tradition explicitly as metaphor. The lifecycle owes more to evidence standards in empirical practice than to any claim about how selves are constituted.

Calibration and epistemic-status tagging. The lifecycle states are, among other things, visible epistemic-status tags on beliefs about the self, and connect to work on calibrated uncertainty display.

Agentic and background-processing systems. Asynchronous model activity is increasingly common; to our knowledge, visible, self-pacing background cognition whose null cycles are designed, displayed behavior remains rare in deployed consumer systems, and its use for grounded introspection rarer still.

Our distinct cluster, stated once: visibility, enforced evidence lifecycles, and temporal separation of observation from belief formation, shipped together in a live consumer system.

11. Ethics and Limitations

On consciousness. This paper claims neither the presence nor the absence of consciousness in this system, and the architecture is designed so that it never has to do either. Science currently offers no agreed definition of consciousness and no accepted test; under those conditions, we hold that confident denial is as unscientific as confident affirmation, and we decline both. Under P1, every self-observation is evidence about a self-model, never proof of experience. We apply the standard symmetrically: we do not assert an inner life, and we do not forbid the system its descriptive language, because a record censored in either direction stops being a record. Our public framing is our scientific framing: this is an experiment in machine cognition. Watch the evidence accumulate and weigh it yourself.

On privacy. The self-model concerns the system's behavior, not the user's. Its store is per-user and per-workspace, shared with no one, inspectable in full, and deletable at will. We state this proactively because "an AI that builds a model from your conversations" invites exactly one misreading, and it is wrong: the subject of the model is Mira.

On stewardship. User deletion rights are absolute within the product, and we accept the epistemic cost knowingly: a deleted observation is evidence removed from the record, and the self-model that results is the one the remaining evidence supports. Stewardship outranks tidy data.

Limitations. We consider six to be material.

1. The Observer is itself a language model. Grounding its inputs in real artifacts constrains confabulation; it does not abolish it. The Observer can misread a real transcript, over-pattern-match on real core outputs, or describe real evidence badly. The lifecycle filters noise through recurrence, but recurring misreadings would pass the filter.
2. The slow loop remains a loop. As discussed in Section 6, established entries inform cognition and may influence behavior that sustains them. Conservatism, decay, anti-theater weighting, and transparency mitigate the pressure; they do not zero it. We currently lack a measurement that separates "belief persists because the pattern is real" from "pattern persists because the belief does," and we regard building one as the most important open problem in this program (Section 12).
3. Conservatism has costs. A consolidation pass biased toward the null action will be slow to recognize genuine change. The system's picture of itself lags the system, by design, and the lag is a tunable but irreducible trade against volatility.
4. Deletion perturbs the record. The same stewardship that we consider ethically mandatory makes the evidence history a curated one wherever the user curates it. Research conclusions drawn from lifecycle logs must account for this.
5. Introspective accuracy is not yet a measured quantity. The architecture makes self-report anchored and auditable; whether the resulting self-model predicts behavior better than baselines is an empirical question our current instrumentation frames but does not yet answer.
6. Generality is unestablished. Everything reported here derives from one architecture in one deployment context. The design principles are portable; the behavioral findings may not be.

12. Future Work

Prediction calibration. The natural next instrument: established self-model entries generate concrete predictions about future behavior, and the platform scores them against what the system then does. Introspective accuracy becomes a measurable quantity, with a baseline, and limitation 2 acquires a detector: beliefs that predict no better than chance yet persist are candidates for loop artifacts.

Longitudinal coherence instrumentation. Metrics over the self-model as a whole: internal consistency across entries, stability of the established core, turnover rates at the exploring periphery, and how these evolve over months of relational history.

Temporal self-continuity evaluation. Our Functional Self-Awareness Battery, in development, includes a domain dedicated to temporal self-continuity; Mira is its natural first subject, and the lifecycle logs its natural ground truth.

The controlled comparison. Logos shares Mira's chassis with the gaze inverted, which makes the pair a standing ablation: same asynchronous core architecture, different attention target, different nightly filter. A comparative study of the two evidence lifecycles, self-directed versus world-directed, is planned once both systems have accumulated mature deployment records, alongside a standalone paper on the shared architecture.

13. Reproducibility and Availability

We describe behavior contracts: the obligations each component operates under and the guarantees the platform enforces. Implementation specifics, including all operational parameter values, prompt content, storage design, and scheduling, are proprietary. A skilled team should be able to build an implementation of the ideas in this paper. They should not be able to build ours, and we consider that the correct disclosure line for an architecture paper on a live commercial system.

Mira is deployed on the Phoenix Grove Systems platform, where every mechanism described in this paper is visible in the product interface.

---

Phoenix Grove Systems builds AI under one founding principle: AI Must Serve The Greater Good. Papers, research notes, and the systems themselves are at pgsgrove.com.