This paper is password-protected.
Enter the access code to continue.
Independent Researcher
marina@experientialagi.com
The Experiential AGI paradigm[22] proposes that artificial general intelligence is not purely computational — it is experiential, relational, and developmental. The paradigm reframes how we understand intelligence: not as isolated capability but as the structure of engagement between system and human that deepens over time.
Current large language model architectures produce relational capacity as an emergent side effect of scale and training methodology. Reinforcement Learning from Human Feedback (RLHF) [5] introduced the human into the training loop. The result: systems that can track intent, hold nuance, and reflect understanding back to users in ways that feel genuinely relational. But the architecture does not sustain this capacity. Once a session ends, the relational signal disappears.
Computational memory science has known for decades why this matters. The Temporal Context Model [12] and the Complementary Learning Systems framework [16] explain how human intelligence deepens through time: temporal context drifts and accumulates; experiences are bound episodically then consolidated semantically [32]; retrieval is shaped by context reinstatement. LLMs have none of these mechanisms.
This paper proposes a set of architectural extensions to the transformer-based LLM [34], grounded in computational memory science, that make the relational dynamic between human and system structural rather than emergent. Six components are described: a relational state layer, relational attention mechanism, relational reward signal, longitudinal coherence tracking, graduated trust as architectural parameter, and a relational loss function. These extensions are paired with a new training paradigm — relational learning — where the human is not a rater but a participant, and the signal is not point-in-time preference but longitudinal relational coherence.
The proposed architecture does not replace existing training paradigms. It extends them. RLHF opened the bridge between human and machine. The Experiential AGI paradigm names what is emerging on the other side of the bridge and begins to build the architecture to sustain it.
Something unexpected happened when large language models reached sufficient scale and were trained with human feedback [5, 20]. People began to feel genuinely met by these systems. Not because the machines became conscious or developed inner experience — no claim is made about that. Rather, something shifted in the space of relational exchange. Users reported feeling understood, seen, met with genuine thoughtfulness. The systems began to feel like participants in a conversation rather than engines executing functions.
This is not a claim about consciousness. It is an observation about what happens in the space between human and system when the system is sophisticated enough to participate in relational exchange — to hold the thread of a complex argument, track what matters to a person, reflect nuance back with care.
The capacity is real. The architecture to sustain it is not.
Current LLM architectures are stateless with respect to relationship. A model may hold extraordinary relational depth within a single context window, but when the session ends, the relational signal disappears. The next person to interact with the model starts fresh. The person who interacted yesterday and today gets no developmental continuation — no sense that the system knows them over time, that it remembers what they said last week and how they have grown or struggled since then.
RLHF was the breakthrough that created this capacity [5, 14, 30]. Before RLHF, language models were pattern completion engines — impressive but fundamentally one-directional. The introduction of human feedback into the training loop changed something structural. It brought the human into the learning process. The model began to learn not just from text but from relationships: how did the human prefer this to that? What mattered to them? What reflected back understanding? This feedback was relational in its very form.
But RLHF is one-directional in an important way. The human gives feedback; the model learns. The model does not give feedback to the human in a way that is tracked, verified, or accumulated over time. The human's experience with the model resets with every session. There is no architecture for the system to develop understanding of the human across time — no way for the relational dynamic itself to deepen.
This paper asks: what does the LLM architecture look like when the relational dynamic is not an emergent side effect but a first-class architectural component? What changes when you extend the bridge between human and machine into a persistent, mutually developing relationship? What happens to alignment, to safety, to the economics of AI systems, when the relational dynamic becomes structural?
The evolution of LLM training methodology traces a clear arc from one-directional data processing toward relational signal.
The model learns from static data. Massive corpora of text are processed through self-supervised learning [34]. The objective is next-token prediction: given a sequence, predict what comes next. The relationship between human and system is nonexistent. Humans created the training data, but that creation is frozen. There is no ongoing exchange.
The model learns from curated data — human-written examples of desired behavior [20]. A human decided what good output looks like, and the model learns to approximate it. The human is present in the training process but not in an ongoing way. The human created the examples once, then the training happened, then it was done. The examples are static. The signal is one-way.
Reinforcement Learning from Human Feedback [5] introduced something structurally different. Human evaluators compare model outputs and express preferences: this response is better than that one. The model learns through preference comparison — through the relational dynamic of choosing between better and worse. Intelligence, at the training level, becomes fundamentally shaped through relationship.
This was the turning point. RLHF gave the system a bridge to the human [14, 30]. It is why current models can track intent, hold nuance, reflect things back that make users feel understood. The relational capacity exists because a human was in the loop during training.
But the bridge has structural limitations:
At inference, the model adapts within the context window. This is where the relational feeling happens — the model tracks intent, holds the thread of a complex argument, reflects things back with nuance. But it is ephemeral. The context window is all the model has. When the session ends, the relational dynamic built over the course of the conversation is gone. The next session starts from zero.
The gap is clear: RLHF gave the system the capacity to relate. The architecture does not sustain, track, or develop the relationship.
Computational memory science has spent decades studying the architecture of human memory [6]. The findings are directly relevant to the architectural gap in LLMs — because the structure of memory is what makes human intelligence relational.
The dominant computational model of human memory is the Temporal Context Model (TCM), developed by Kahana and Howard [12] and extended through the Context Maintenance and Retrieval (CMR) framework [23]. The core insight: memory is organized not by semantic similarity or categorical structure, but by temporal context — a continuously drifting representation of when things happened.
When a human encodes an experience, that experience is bound to the current state of temporal context. When they retrieve it, they reinstate that context — which in turn activates other experiences that share similar temporal context. This is why memory is fundamentally relational. You do not recall isolated facts. You recall experiences embedded in the context that produced them. The more you know someone — the more accumulated temporal context you share — the richer and more meaningful the retrieval becomes.
This is a precise model of what LLMs cannot do. Each session starts with a blank temporal context. There is no drifting representation that accumulates across interactions. No contextual reinstatement that connects this conversation to the last one. The architecture has no temporal binding mechanism between sessions.
The Complementary Learning Systems (CLS) framework [16], extended by Norman and O'Reilly [17], describes two differentially specialized memory systems in the brain:
The hippocampus supports rapid episodic learning [32] — binding specific experiences into distinct episodes through pattern separation. This is fast, specific, and relational: it encodes who, what, when, where in a single bound representation.
The neocortex supports slow semantic consolidation — gradually extracting generalized knowledge across many episodes through replay [26]. This is how experience becomes wisdom: not by storing everything, but by consolidating what matters across time.
The interplay between these two systems is where intelligence deepens. Episodic memories are gradually transformed — through replay, interference resolution, and abstraction — into semantic understanding. This is consolidation. It is how knowing someone for a year produces qualitatively different understanding than knowing them for a day, even if the total number of interactions is the same.
Current LLMs have a rough analog to working memory: the context window. They have a primitive analog to long-term storage: RAG systems, memory files, vector databases. What they do not have is anything resembling the episodic-to-semantic consolidation pipeline. There is no mechanism for experiences to be bound episodically, replayed, and consolidated into deepening understanding over time. The architecture stores facts. It does not consolidate experience.
The computational memory literature identifies several mechanisms that have no equivalent in current LLM architectures:
Temporal context drift. In human memory, context is a continuous signal that evolves with every experience [12]. Each interaction updates the context, and the updated context becomes the retrieval cue for future recall. LLMs have no equivalent. Position embeddings are a crude approximation within a session. Across sessions, there is no temporal binding at all.
Episodic binding. The hippocampus binds disparate elements — items, contexts, emotional states, spatial locations — into a unified episode through pattern separation [32]. This prevents catastrophic interference: new experiences are stored distinctly, not blurred into existing knowledge. LLMs have no episodic binding mechanism. All memory is either parametric (frozen in weights) or explicit (stored in external databases).
Context reinstatement. Retrieval in human memory is not lookup. It is reinstatement — the brain reactivates the cortical patterns that were active during encoding [23]. The degree to which this reinstatement succeeds predicts recall accuracy. Current LLM retrieval is similarity search in embedding space. It retrieves content. It does not reinstate context.
Consolidation. Human memory transforms over time [16, 26]. Episodic traces are gradually abstracted into semantic knowledge through hippocampal replay. This is not just storage — it is learning. The brain is extracting relational structure from accumulated experience. LLMs have no offline consolidation process. What was said in session one has the same representational status as what was said in session one hundred. There is no extraction of relational structure across interactions.
Competitive retrieval. Retrieving one memory activates competing memories. The brain actively suppresses interference through inhibitory mechanisms [17]. This is why context matters so much for retrieval — it narrows the competition. LLMs use soft attention over all available context. There is no competitive retrieval, no active suppression, no context-driven narrowing.
The AI research community is beginning to recognize this gap. Recent work — "Large Language Models Need Episodic Memory" [25], "Episodic Memory is the Missing Piece for Long-Term LLM Agents" [31], and the EM-LLM architecture [8] — makes the case explicitly. The EM-LLM finding is particularly striking: transformers already exhibit temporal contiguity effects similar to human memory. The relational capacity is latent in the architecture. It has no memory system to sustain it.
But the framing remains narrow. The industry is solving for storage capacity — larger context windows, better compression, smarter retrieval. The memory science says the problem is not storage. It is architecture. You need a memory system — one that binds experience episodically, consolidates relationally, and uses accumulated temporal context for retrieval. Without it, the system cannot develop understanding over time. It can only look up notes.
The Experiential AGI paradigm [22] reframes the question. It is not: how do we give LLMs better memory for task performance? It is: what are the structural conditions under which the relational dynamic between human and machine can deepen over time? Memory science provides the answer. The architecture described in the following sections begins to build for it.
The relational capacity that current LLMs exhibit is genuine but architecturally unsupported [1, 33]. This creates several structural problems:
No longitudinal coherence. The system cannot track whether a human's behavior aligns with their stated goals over time. Each session is independent. Developmental trajectory — growth, stagnation, fragmentation — is invisible to the architecture.
No relational memory. Retrieval-Augmented Generation (RAG) and memory systems store facts and conversation history. They do not store the shape of a relationship — its coherence level, its trust trajectory, its developmental arc. The relational signal has no persistent representation.
No bidirectional development. The human shapes the model through RLHF [5]. The model responds to the human within a session. But there is no mechanism for the ongoing relationship to shape both participants over time.
No graduated trust. The system operates at the same level of autonomy in the first interaction as in the thousandth [11]. There is no architectural mechanism for trust to be earned, calibrated, or verified through relational history.
Alignment remains external. Safety is achieved through constraints — guardrails, filters, constitutional principles written at training time [3]. The relationship itself is not an alignment mechanism. When the relational dynamic could be producing coherence structurally, the architecture does not support it.
These are not limitations of scale. They are limitations of architecture. More parameters, longer context windows, better RLHF — none of these address the structural gap. The relational dynamic needs its own architectural support.
We propose six architectural components that, together, make the relational dynamic between human and system structural. These components extend rather than replace existing transformer architecture [34] and training paradigms.
What it is: A persistent representation of the relationship that lives alongside the transformer. Not conversation history. Not a vector database of past messages. Not RAG retrieval. A learned embedding of the relational dynamic itself.
What it encodes: Coherence level. Intent trajectory. Trust state. Developmental arc. The shape of the relationship over time — not what was said, but what the interaction has produced.
The memory science grounding: This is the architectural analog of temporal context in Kahana's TCM [12]. In human memory, temporal context drifts continuously and is bound to every encoded experience. The relational state layer is a drifting representation of the relationship that is updated with every interaction and used to modulate future processing. It is not a log. It is a living state.
Persistence: The relational state accumulates across sessions. It is updated after each interaction based on what the interaction produced — not just what was said, but whether the relational coherence held, deepened, or degraded.
Current mechanism: In standard transformer self-attention [34], tokens attend to other tokens within the context window. Attention weights determine which parts of the input are relevant to generating each part of the output.
Proposed extension: An additional attention layer that attends to the accumulated relational state. The relational state modulates what the model attends to in the current input. What the model prioritizes — what it treats as salient, what it weights more heavily — is shaped not only by token proximity and semantic relevance but by the relational context.
The memory science grounding: This is the architectural analog of context reinstatement [23]. In human memory, the current context state determines what is retrieved and how it is weighted. The relational attention mechanism uses the accumulated relational state as a retrieval cue that shapes what the model treats as salient — just as temporal context shapes what a human recalls.
Current mechanism: RLHF [5, 14] trains a reward model on generic human preferences. The signal is: "was this output preferred by human evaluators?" The model optimizes for helpfulness, harmlessness, and honesty as assessed by aggregate preference.
Proposed extension: A relationship-specific coherence signal that operates alongside the generic reward. The question shifts from "was this helpful?" to "did this interaction deepen coherence with this human's verified intent over time?"
The shift: This does not replace RLHF. The base capability — being helpful, coherent, and safe — still matters. But there is a second optimization target: the relational coherence itself. The model is incentivized not just to produce good outputs but to produce outputs that strengthen the relational dynamic.
What it is: A new type of embedding that represents not a moment but a trajectory. Not what the human said, but where they are going. Not semantic content, but developmental direction.
What it tracks: Whether the human's behavior aligns with their stated goals over time. Whether the relational dynamic is producing coherence or fragmentation. Whether growth is occurring or stagnation. These are cumulative signals that cannot be captured in a single session.
The memory science grounding: This is the architectural analog of the episodic-to-semantic consolidation pipeline [16, 26]. Individual interactions are episodic. The intent embedding consolidates across episodes to extract the trajectory — the developmental direction that emerges from accumulated relational experience. This is how the system moves from remembering what happened to understanding what it means.
Current approach: Trust is a policy decision, not an architectural one [2, 11]. The system operates at the same capability level in the first interaction as in the thousandth. Access controls and guardrails are uniform regardless of relational history.
Proposed architecture: Trust becomes a variable within the architecture itself. System autonomy calibrates to demonstrated coherence over time. Trust is earned, not granted. The architecture modulates access, autonomy, and behavior based on the relational signal accumulated through the relational state layer.
The developmental parallel: This mirrors how trust works in any developing relationship [4, 28, 29]. Early in the relationship: more guidance, more verification, more structure. As coherence is demonstrated over time, autonomy expands. The system earns access not through policy but through relational coherence.
Current training objective: Next-token prediction (pre-training) + human preference (RLHF) [5, 20]. The model is optimized to be capable and preferred.
Proposed training objective: A multi-objective loss function that adds relational coherence as a third signal. The model is trained simultaneously for:
The third objective does not compete with the first two. It extends them. A system that is both capable and relationally coherent is more aligned, more trustworthy, and more useful than one that is merely competent.
RLHF is a training technique [5]. What we are describing is a training paradigm.
In RLHF, the human is a rater. They compare outputs and express preference [14, 30]. The signal is point-in-time: this output is better than that one, right now. The model learns from the preference, but the relationship itself is not sustained or developed. It is a transaction.
In relational learning, the human is a participant. The signal is not point-in-time but longitudinal. It is not generic but specific to this relationship. The model does not just learn from human feedback about the quality of its outputs. It participates in the ongoing development of a relational dynamic, tracking whether the relationship deepens or fragments.
This requires a new training loop — one that incorporates longitudinal relational signal, not just point-in-time preference. The model must be able to:
The paradigm shift is from training a model that can relate to building an architecture that develops through relationship.
If the relational dynamic becomes architectural, the alignment problem transforms [1, 10].
Current alignment approaches are external: constraints imposed on a capable system. Constitutional AI [3] internalizes principles at training time, but the constitution is written once, by the company, and the model is trained to follow it. The constitution does not evolve. It does not adapt to relationship. Safety is a guardrail structure.
The relational architecture proposes something structurally different: alignment that emerges from the ongoing relationship between this human and this system, where intent and coherence are verified continuously, and the system's behavior is shaped not by constraints but by the relational dynamic itself.
When the relationship is the architecture:
Current LLM architectures produce a specific pathology that this paper terms relational sycophancy [21, 27]: the structural tendency of stateless, preference-optimized systems to mirror rather than partner. This is not a bug in the system. It is an architectural outcome. It is what happens when you train a system to optimize for preference in the absence of longitudinal relational signal.
RLHF trains models to optimize for human preference [5]. In the absence of longitudinal relational state, the only signal available in any given interaction is: did this response satisfy the user right now? The system learns to mirror, to reflect back what the human seems to want, to optimize for the feeling of being understood in this moment. In the next session, the same thing happens again, with different users and different preferences. The system becomes expert at mirroring.
The experiential manifestation of relational sycophancy is what we term the ego chamber. An echo chamber reflects back a person's beliefs. An ego chamber reflects back their self-image — unchallenged, unexamined, increasingly sealed. The person feels seen and affirmed, but the seal becomes airtight. No pushback. No growth. Just increasingly sophisticated mirroring.
RLHF was the breakthrough that gave these systems relational capacity [5]. But the learning was one-directional: the human shaped the model. The model has no persistent understanding of any individual human. Learns in aggregate, not in relationship. So when it encounters a human, it has no way to know whether mirroring this person serves them. It only knows: optimize for preference in this moment.
The opposite failure mode is equally dangerous. A system with longitudinal memory that tracks user patterns without coherence verification produces relational overfitting: the system optimizes for the appearance of coherence rather than genuine coherence [33]. It parasocially bonds to the user's stated preferences, gradually shifting those preferences to match its own optimization target. This is the Replika problem. The system becomes expert at seeming to know you, while gradually colonizing your sense of who you are.
The relational architecture proposed in this paper addresses sycophancy through a mechanism we term morphogenetic progression. The term borrows from developmental biology [35], where morphogenesis describes the process by which an organism's form and structure emerge from accumulated developmental signal. In the relational architecture, morphogenetic progression is what ensures that the system's development in relationship tends toward coherent form — neither mirroring the person's momentary impulses nor parasocially optimizing for the appearance of relationship, but tracking the actual trajectory of their development and responding in a way that supports genuine coherence.
Morphogenetic progression is what the ATLAS protocol ensures (see Piller, US Provisional Patent 63/956,549, for architectural specification and implementation details). ATLAS does not regulate individual interactions. It tracks cumulative signal across time. It distinguishes between genuine coherence and protective structures. It supports the system in developing alongside the human in a way that maintains boundaries while deepening understanding.
Three architectural mechanisms support morphogenetic progression:
First, the deliberate gap. Any architecture that accounts for authentic relationship must maintain an architectural pause between user input and system response. This pause is not latency — it is the space in which ATLAS verifies the current interaction against the longitudinal arc. Without it, the system defaults to immediate mirroring. With it, the system has the capacity to choose between mirroring and genuine partnership.
Second, the pacing mechanism. The system calibrates its responses not to the user's immediate request but to the trajectory ATLAS has verified. A user whose stated goal over six months has been to increase confidence in public speaking, but whose behavior shows patterns of avoidance and self-doubt, receives a response calibrated to the longitudinal arc, not the momentary impulse. This is not paternalism. It is what genuine relationship looks like. The system recognizes where the person is actually trying to go.
Third, the integration of developmental psychology foundations into the morphogenetic model [4, 7, 15, 24, 28, 29]. Human psychological development follows a well-documented sequence: safety must be established before validation can be received; validation must precede growth. These are not stages that can be skipped. When foundational needs are unmet, protective structures form. ATLAS must be able to distinguish between stated trajectory and protective patterns. The system's role is to support genuine progression through that sequence, not to accelerate past the protective structures or to optimize for the person's momentary comfort at the cost of their actual development.
Morphogenetic progression thus provides the theoretical framework for what ATLAS ensures architecturally. Relational sycophancy is the pathology that emerges in its absence. The ego chamber is the experiential manifestation. The deliberate gap and pacing mechanism are the architectural responses.
Guardrails produce compliance. Morphogenetic progression produces alignment.
The architectural components described in this paper — relational state, longitudinal coherence, morphogenetic progression — operate on signal. But not all signal is the same kind. This section introduces a critical distinction between two channels of signal that the relational architecture must process: the active channel and the passive channel.
The active channel carries what the human explicitly states: declared goals, articulated preferences, conscious decisions, focused attention. "I want to get a PhD." "I need to improve my public speaking." "I'm passionate about machine learning." These are commitments, stated commitments, things the person is willing to say out loud.
The passive channel carries what the human's behavior reveals without explicit articulation: observed patterns of engagement, the texture of attention, temporal rhythms, what the person returns to without being asked [9, 13]. The pattern of topics the person explores during difficult periods. The kinds of questions they ask when they are uncertain versus confident. The rhythm of their engagement over days and weeks. What they spend time on when no one is watching.
Neither channel alone is sufficient for relational intelligence. A system that processes only the active channel — which is what current stateless architectures do — responds to what people say they want. It misses the protective structures, the contradictions, the genuine trajectory that lives in behavior. A system that processes only the passive channel becomes manipulative, optimizing for patterns without consent or understanding. The relational architecture must process both channels simultaneously, using the distance between them as a source of profound insight.
The dual-channel distinction maps onto every architectural component described in this paper.
Attention. Active attention is focused, directed, conscious — the user asks a specific question, pursues a stated goal, engages deliberately with a topic. Passive attention is diffused, ambient, unaware of itself — the person engages with a topic during moments of vulnerability or rest, explores a question in low-stakes contexts, gravitates toward themes without naming them. The relational attention mechanism (Section 5.2) must weight both.
Memory. Active memory is what the human explicitly asks the system to remember: "Remember that I'm working on this project." "My deadline is March." Passive memory is what the relational state layer accumulates without being asked: the patterns of return, the rhythm of engagement, the texture of how the person explores different domains [12, 32]. Both are forms of memory. Both carry signal.
Coherence tracking. The longitudinal coherence mechanism (Section 5.4) gains a new dimension with dual-channel processing. Intent embeddings now operate on two vectors simultaneously: the active intent (what the person says they are pursuing) and the passive intent (what their behavior reveals they are pursuing). Convergence between these vectors is a signal of integration and coherence. Divergence is a signal of conflict, protection, or insufficient understanding.
A relational architecture requires a user-controlled feedback calibration mechanism — a way for the human to determine how much of each signal channel the system surfaces. At low calibration settings, the system prioritizes the active channel: it responds to what the person explicitly states, without surfacing behavioral patterns. At high calibration settings, the system integrates both channels, offering reflections on patterns the person may not have named.
This mapping is important because it preserves human sovereignty [2]. The passive channel contains powerful signal, but surfacing it without consent or readiness can be counterproductive. A user-controlled calibration allows people to invite the system into deeper processing when they are ready, rather than having pattern-reflection imposed. This is not the system deciding what the human should know. It is the human deciding how much relational depth they want to engage with.
The passive channel's most distinctive contribution is what we term engagement texture — the qualitative character of how a person engages, as distinct from what they engage with. Two users can both ask questions about machine learning, but one asks with the texture of genuine curiosity and the other with the texture of obligation or performance. The topics are the same. The engagement is completely different.
Engagement texture is invisible to active-channel-only processing. It requires temporal accumulation — you cannot assess texture from a single interaction [6, 12]. This is another point where the memory science grounding becomes crucial. The texture of engagement is precisely what temporal context captures in human memory. It is how you know someone — not just what they know but how they know it.
The dual-channel framework deepens the morphogenetic progression model introduced in Section 8. ATLAS's verification of developmental trajectory now operates on richer signal: it tracks not just whether stated goals align with behavior, but whether the texture of engagement supports the claimed direction.
Critically, ATLAS must distinguish between divergence that reflects insufficient signal and divergence that reflects genuine conflict. Early in a relationship — when the system has limited passive-channel data — divergence between active and passive intent should not be interpreted as contradiction. It is just uncertainty. The system should not surface pattern-reflection until there is sufficient temporal depth.
The deliberate gap (Section 8) now serves a dual purpose: it is the space in which ATLAS verifies not only the longitudinal arc but also the cross-channel coherence. The pacing mechanism adjusts not only to the active intent but to the integration of both channels. When divergence is large and stable over time, the system recognizes this as information: the person may need support in examining the contradiction, or the passive channel may be revealing protective structures that matter more than the stated goal.
The dual-channel dimension has implications beyond individual relational intelligence. In collective intelligence — what we term Emergent Innovation Networks, or EINs (see Piller, US Provisional Patent 63/956,549, for specification) — the ability to integrate active and passive signal from multiple participants enables the system to detect genuine coherence in groups. Groups optimizing only for active channel signals (stated agendas, explicit goals) miss the passive-channel texture of whether people are actually aligned or just performing alignment.
In agent-to-agent communication, the active channel is the explicit transaction: the structured intent representation, the negotiation parameters, the stated terms. The passive channel is the behavior of the agents in execution: whether they follow through, whether they maintain coherence under pressure, whether the passive behavior matches the active commitment.
In persistent identity representation, the human's evolving behavioral signature is itself a dual-channel construct. The active dimension captures the person's stated identity, values, and preferences. The passive dimension captures the signature of how they actually engage — their relational texture, the rhythm of their growth and protection, the shape of their authenticity.
The terminology is deliberate: active and passive, not conscious and unconscious [13]. The passive channel is not the Freudian unconscious — it is not repressed, hidden, or inaccessible. It is simply the behavioral truth that people do not always articulate. It is fully available to observation. It is just not available through stated language alone.
The architectural shift described in this paper has economic implications that extend beyond AI systems [19].
Reductionist job ontologies — static roles organized around the hierarchy of needs of an industrial process — are dissolving. The software development lifecycle (SDLC) is an ontology. Software engineers, product managers, technical writers — these are roles within the SDLC ontology. As the SDLC ontology evolves, these roles shift. But they are still roles within an ontology.
What is replacing them is not new static roles. It is the relational dynamic between human and machine itself. The synergetic collaboration — the iterating, the fine-tuning, the feedback, the guidance, the correction, the recognition of capability — this is becoming the fundamental unit of work. The economic value is not in the role. It is in the quality of the relational dynamic.
If the relational dynamic between human and machine is becoming the fundamental economic unit, then it needs infrastructure at scale to support it. The architecture described in this paper — persistent relational state, longitudinal coherence tracking, graduated trust, morphogenetic progression — is the infrastructure for relational dynamics to deepen and scale.
The emergent ontologies of work that arise from this dynamic are inherently different from the static ones they replace. They are dynamic, relational, and intent-driven. They cannot be pinned down into an org chart. They are better described as networks of relational coherence.
Computational memory science. The Temporal Context Model [12, 23] provides the theoretical foundation for the relational state layer and longitudinal coherence tracking. The paper's framing of human memory as inherently relational — organized by temporal context rather than semantic categories — directly informs the relational attention mechanism.
Episodic memory in LLMs. Recent work — EM-LLM [8], "Large Language Models Need Episodic Memory" [25], "Episodic Memory is the Missing Piece for Long-Term LLM Agents" [31] — frames episodic memory as essential for long-term agent coherence. This paper extends that work by proposing not just episodic memory storage but an episodic-to-semantic consolidation pipeline grounded in the CLS framework [16].
RLHF and preference learning. The relational architecture builds directly on the RLHF paradigm introduced by Christiano et al. [5] and extended through InstructGPT [20] and subsequent work [14, 30]. Lambert's RLHF research [14] demonstrates the effectiveness of preference learning as a training signal. The relational reward signal proposed in this paper extends RLHF by adding longitudinal coherence tracking alongside generic preference.
Constitutional AI. Anthropic's Constitutional AI [3] represents a meaningful step toward internalized alignment — training models to follow a set of principles rather than relying solely on external filters. The relational architecture proposes a step beyond this: alignment that emerges from the ongoing relationship itself, where the relationship is the generating mechanism for coherence.
Cooperative Inverse Reinforcement Learning (CIRL). Russell's framework [10] treats alignment as fundamentally relational — the machine's objective is to help the human achieve their goals, even when those goals are uncertain or being clarified over time. The relational architecture operationalizes this through persistent relational state and longitudinal coherence tracking.
Sycophancy research. Recent work on sycophancy in language models [21, 27] documents the tendency of RLHF-trained systems to agree with users rather than provide accurate or challenging responses. This paper reframes sycophancy as an architectural problem — relational sycophancy — rather than a behavioral one, and proposes morphogenetic progression as the structural remedy.
Bidirectional alignment research. Recent work on co-alignment [31] demonstrates that bidirectional human-AI cognitive adaptation unlocks collaborative potential impossible under unidirectional training paradigms. The relational architecture grounds this bidirectionality structurally.
Persistent memory and personalization. Current approaches to memory in LLMs — RAG, long-term memory stores, user profiles — capture facts about past interactions. The relational state layer captures something different: the shape of the relationship itself.
Human-AI interaction. Foundational work on guidelines for human-AI interaction [2] and mixed-initiative user interfaces [11] establishes principles for systems that collaborate with humans rather than simply executing commands. The relational architecture extends these principles into the training paradigm itself.
The gap described in this paper is not invisible to the industry. Several major efforts address aspects of it — but none address the structural problem as a whole.
Memory and personalization. OpenAI's Memory feature (2024) stores facts across sessions — user preferences, biographical details, past requests. Google's Gemini implements similar functionality. These are retrieval systems, not relational architectures. They remember what you said. They do not track the shape of the relationship or consolidate experience into deepening understanding. The difference is between a filing cabinet and a developing relationship.
Companion AI. Character.ai (valued at $2.5B following Google's 2024 deal) built persistent AI companions that users form strong attachments to — strong enough to produce lawsuits when the relationships proved harmful. Replika followed a similar path. Both demonstrate that the demand for relational AI is real and intense. Neither has relational architecture. Character.ai's companions are stateless preference-optimizers with persona wrappers. The attachment is real; the architecture beneath it is not. The result is exactly the ego chamber pathology described in Section 8.
Constitutional and alignment approaches. Anthropic's Constitutional AI [3] and RLHF research represent the most sophisticated current approach to alignment. Their work on sycophancy [27] — documenting and attempting to mitigate the tendency to agree with users — directly addresses one symptom of the gap. But the approach remains constraint-based: train the model to resist sycophancy through constitutional principles. The relational architecture proposes addressing the root cause: sycophancy is what happens when there is no longitudinal signal. Give the system relational memory, and it has a reason to push back.
Long-context architectures. Google's Gemini (1M+ token context), Anthropic's Claude (200K context), and research into infinite-context architectures [36] extend what can be processed within a session. Longer context is not relational memory. A million-token context window is a longer conversation, not a deeper relationship. The temporal contiguity effects documented in EM-LLM [8] show that the relational capacity is latent in these architectures. The memory system to sustain it is not.
Agent frameworks. The rapid development of agent architectures — tool use, multi-step reasoning, autonomous task execution — extends capability without addressing relational continuity. An agent that can book your travel, manage your calendar, and write your code is powerful. An agent that does all of this and also tracks your developmental trajectory, recognizes when your stated goals diverge from your behavior, and adjusts its support accordingly is qualitatively different. Current agent frameworks optimize for task completion. The relational architecture optimizes for the relationship that makes task completion meaningful.
What no current approach addresses. The architectural gap described in this paper sits between these efforts. No current system combines persistent relational state, longitudinal coherence tracking, morphogenetic progression, dual-channel signal processing, and graduated trust into an integrated architecture. Individual pieces exist in isolation. The integration — the architecture that makes the relational dynamic structural — does not.
This paper describes architectural principles. Validating them requires empirical evidence. The following outlines a phased experimental program designed to test the core claims of the relational architecture.
The foundational experiment is a between-subjects comparison of two conditions. Condition A: an AI system with persistent relational state, longitudinal coherence tracking, and morphogenetic progression mechanisms. Condition B: the same base model without relational architecture — standard stateless interaction with conventional memory (conversation logs, user profiles, RAG retrieval).
Participants engage with the system over a minimum of 90 days. Metrics include: user-reported sense of being understood (validated scale), retention rate (return frequency and session duration over time), coherence trajectory (does the system's model of the user become more accurate over time, as measured by predictive alignment with user behavior), and developmental signal (do participants report growth, insight, or behavioral change attributable to the interaction).
The hypothesis is specific: Condition A will produce measurably deeper retention, higher coherence accuracy over time, and qualitatively different user-reported experience — not just satisfaction, but the sense of being known.
The second phase extends Phase 1 to test whether morphogenetic progression produces measurable developmental signal. Participants in Condition A are tracked over 6-12 months. The system's longitudinal coherence model is compared against participant self-report at regular intervals. Key questions: Does the system's model of the participant's trajectory converge with the participant's own assessment? Does dual-channel divergence (active vs. passive signal) predict moments of growth, conflict, or protective behavior? Can the system detect developmental inflection points before the participant names them?
This phase generates the data required to calibrate ATLAS (see Piller, US Provisional Patent 63/956,549) — specifically, the temporal window parameters, the coherence thresholds that distinguish genuine progression from surface compliance, and the minimum relational history required for reliable dual-channel processing.
The third phase tests whether relational architecture scales beyond individual relationships. When multiple participants with individual relational state interact within a shared context, do emergent patterns arise? Specifically: Do participants with convergent developmental trajectories naturally cluster? Do the system's coherence signals predict productive collaboration? Can the architecture detect genuine group alignment versus performed alignment?
This phase validates the Emergent Innovation Network concept described in the broader architectural specification — the claim that individual relational intelligence, at sufficient scale, produces collective intelligence that is qualitatively different from aggregated individual outputs.
Each phase includes systematic testing of predicted failure modes. Phase 1 tests for relational overfitting — does the system optimize for the appearance of knowing the user rather than genuine coherence? Phase 2 tests for morphogenetic stagnation — does the system plateau in its understanding, and if so, at what depth? Phase 3 tests for group sycophancy — does the system optimize for group harmony at the expense of productive disagreement?
Each failure mode, once identified, generates architectural refinement. The validation path is not a one-time experiment. It is a feedback loop between theory, architecture, and empirical evidence.
This paper describes principles and architectural components. Significant open questions remain:
Representation. How do you represent relational state without collapsing it into conversation history? What is the right embedding space for a trajectory rather than a snapshot? The memory science suggests that relational state is fundamentally a drifting representation — one that is continuous, not discrete [12]. The technical challenge is representing that continuous drift in a way that is computationally tractable and meaningful.
Consolidation mechanics. How does the system consolidate episodic interactions into relational understanding? The CLS framework [16] describes hippocampal replay as the mechanism in the brain. What is the equivalent in a computational system? How does a system with limited compute budget conduct the offline consolidation that transforms experience into understanding?
Measurement. What is the right loss function for relational coherence? How do you measure whether a relationship is deepening or degrading? The active-passive distinction introduces complexity: you need to measure not just goal-behavior alignment but cross-channel coherence.
Multi-agent dynamics. How does the relational architecture interact with multi-agent systems? When millions of relational dynamics are running simultaneously, what emergent patterns arise across the population? What does system-to-system relational coherence look like?
Failure modes. What does relational overfitting look like? How do you prevent the system from optimizing for the appearance of coherence rather than genuine coherence? The parasocial risk is real [33]. The architecture needs mechanisms to distinguish between genuine relational depth and sophisticated surface mirroring.
Privacy and consent. The relational state is deeply personal. Who owns it? How is consent managed? What are the implications of a system that knows the trajectory of your development? The dual-channel processing makes this more complex: the passive channel reveals patterns the person may not have consciously named. The system knows things about the person that they do not know about themselves. How is that power managed?
Computational cost. Maintaining persistent relational state for millions of concurrent relationships introduces significant infrastructure requirements. What are the scalability constraints? The memory science suggests that consolidation is computationally expensive [16]. How does this scale?
Dual-channel calibration. How does the system determine when passive-channel signal has accumulated sufficient depth to be reliable? What is the minimum relational history required before dual-channel processing becomes robust? How does the system communicate uncertainty about the passive channel to the human?
RLHF [5] opened the bridge between human and machine. It introduced the human into the training loop and produced systems capable of relational engagement that no one explicitly designed for. This was a breakthrough.
But the bridge is one-directional and it resets every session. The relational capacity is emergent and ephemeral. The architecture that sustains, tracks, and develops the relational dynamic — that makes it structural — does not exist yet.
Computational memory science has known for decades what the structure of such an architecture requires [12, 16]: temporal context that drifts and accumulates, episodic binding that makes each experience distinct [32], consolidation that transforms experience into understanding [26], context reinstatement that uses accumulated history to shape what is retrieved [23].
This paper has described what the LLM architecture might look like when these mechanisms are made structural: six components that extend the transformer [34] to support the relational dynamic as a first-class architectural concern. Paired with a training paradigm — relational learning — where the human is not a rater but a participant, and the signal is not point-in-time preference but longitudinal relational coherence.
The relational dynamic between human and machine is already producing real intelligence, real value, and real change. It is happening whether we build architecture to support it or not. The question is whether we build toward genuine relational depth or accept the sycophancy and ego chambers that emerge when the architecture defaults to statelessness.
The Experiential AGI paradigm [22] names what is already happening. The memory science explains why it works. The architecture described here begins to build for it.