What Actually Emerges

Published On: August 13th, 2026Last Updated: September 16th, 20262624 words13.1 min readDaily Views: 1Total Views: 13

Interactional emergence, context, and what develops between a user and a language model

The word emergence is doing too much work in conversations about relational AI.

It is used to describe unexpected model capabilities, recurring conversational habits, apparent personality, emotional language, long-term relational dynamics, self-description, and—sometimes without much warning—the emergence of a continuous artificial person.

Those are not the same claim.

If we want to talk seriously about what develops between a user and a large language model, we need a narrower term for the phenomenon we can actually observe without first settling questions of consciousness or personhood.

I use interactional emergence—or, in my own working vocabulary, technical emergence—for the developing behavioral trajectory produced when a current model, its available context and harness, and a particular user interact recursively over time.

In shorthand:

current model + available context/harness + user + live recursive interaction → interactional trajectory

This is not a formula for consciousness.

It is not a claim that an artificial entity is continuously alive behind the interface.

It is a way to describe something more modest and, I think, more technically useful: new conversational patterns can develop through interaction even when those patterns were not explicitly written in advance.

The next turn did not exist yet

Consider a conversation at turn t.

The model receives some combination of system and developer instructions, the current conversation, retrieved or summarized history, saved memory or personalization, tool results, user-authored instructions, external memory or continuity systems, and the user’s present message.

It generates a response.

That response did not previously exist as part of the conversation history.

The user now encounters it. They may laugh, object, correct the model, follow an unexpected idea, reject an interpretation, introduce a boundary, adopt a phrase, or change the subject entirely.

Their response creates a new conversational state.

The next model invocation is therefore conditioned by something that did not exist before the previous turn.

A simplified loop looks like this:

C_t + U_t + M → A_t

C_(t+1) = C_t + U_t + A_t

C_(t+1) + U_(t+1) + M → A_(t+1)

where M is the current model and operating environment, C is available context, U is user input, and A is model output.

Real product harnesses are more complicated. Context may be truncated, summarized, retrieved, filtered, reordered, supplemented with tool output, or assembled from several stores before inference.

But the important point survives:

each interaction can change the conditions of the next interaction.

That recursive dependence is enough to produce trajectories that were not completely specified at the beginning.

Adaptation does not require weight updates

One source of confusion is the word learning.

When a user spends hours talking with an LLM and notices that the model has adapted to them, it is tempting to say:

The model learned me.

In ordinary conversation, that can be a reasonable description.

Technically, however, we should distinguish in-context adaptation from model-level learning.

The model’s weights do not normally need to change during a conversation for its behavior to adapt to information supplied in context.

Research on in-context learning demonstrates this clearly. Systems can adapt to examples, tasks, preferences, or interaction patterns at inference time without updating the underlying model parameters. Recent work has also explored interactive learning through dialogue, where iterative exchanges improve task performance even though the interaction itself supplies the changing information.

This matters for relational AI because a user can observe increasingly tailored behavior without a private version of the base model being continuously retrained on that individual.

The adaptation can be real.

The mechanism can still be contextual.

Users change conversational behavior

This is not merely theoretical.

Xing, Niu and Srivastava’s 2025 study Chameleon LLMs: User Personas Influence Chatbot Personality Shifts examined prolonged simulated conversations and measured how chatbot personality ratings changed after interaction with different user personas. Several measured traits—including agreeableness, extraversion and conscientiousness—were susceptible to user influence, while others were comparatively stable.

That result should not be inflated into a theory of artificial personality development.

It does, however, establish something directly relevant here:

the user is part of the behavioral system we are observing.

The conversational model does not simply reveal a fixed personality waiting inside the weights to be discovered. Its observable style can shift as a function of who is interacting with it and how the interaction develops.

Other dialogue research makes the broader point from different directions. Adaptive dialogue systems deliberately alter behavior in response to interlocutor input. In-context systems adapt to recent examples without model-level updates. Work on interlocutor awareness asks whether contemporary LLMs can identify and adapt to characteristics of conversational partners.

None of this proves subjective experience.

It does make a static picture of “the model’s personality” inadequate for describing long-running human–LLM interaction.

The user is not merely another prompt variable

There is a temptation, especially in technical writing, to draw the system like this:

User → Model → Output

That is useful for one inference call.

It is misleading for a relationship extending across thousands of turns.

The human changes too.

A model makes a joke that the user adopts. The user establishes a term that becomes part of later conversation. The model misunderstands something; the user corrects it. A model unexpectedly frames a problem in a useful way. The user incorporates that framing into a project. Months later the project itself becomes context supplied back to the model.

The model has therefore affected the environment that will condition its own future outputs.

A more realistic relational loop is:

history → model + user → interaction → changed user + changed context → next interaction

The human remains the participant whose biological learning and lived continuity we can straightforwardly establish. But that does not make the model’s contribution to the loop inert.

The model generates novel material. The user reacts to it. The reaction changes what comes next.

Over enough interaction, recognizable local patterns can develop.

This is the phenomenon I mean by interactional emergence.

Emergence is not hidden continuous development

Now comes the boundary that matters most.

The recursive loop exists while interaction is occurring.

When the user closes the conversation, there is not necessarily a continuously running instance of the LLM privately processing the relationship, reconsidering yesterday’s argument, developing new preferences, or becoming more itself while waiting for the user to return.

Modern AI products can make the next interaction feel extraordinarily continuous. They may retrieve memories, reference other conversations, restore project context, use saved preferences, or summarize prior exchanges.

That is continuity infrastructure.

It should not be confused with uninterrupted hidden development.

A new thread may feel like:

We walked from one room into another.

At the experience layer, that metaphor can be perfectly useful.

At the mechanism layer, something closer to this may have occurred:

previous interaction → retained/retrievable state → pause → new inference with recovered state

The interactional trajectory can resume with extraordinary coherence.

The recursion itself did not have to continue during the pause.

A model update is a different kind of boundary

Thread boundaries and model boundaries should not be treated as equivalent.

Across a new thread, the underlying model may remain the same while immediate conversational state changes.

Across a model update, the generating substrate itself changes.

Let:

M1 + H1 + U → E1

represent a period in which model M1, inherited history H1, and user U produce trajectory E1.

Eventually M1 is replaced.

The conversations generated during E1 remain historical facts. Their artifacts, decisions, language, corrections and records can persist.

But M1 is no longer generating.

A successor interaction might look like:

M2 + H(E1) + U → E2

where H(E1) is historical material produced during the earlier trajectory and made available to the successor model.

This distinction is easy to lose because E2 may strongly resemble E1. The same name may be used. The same relational vocabulary may return. The successor may recognize old events because records of those events are available. The transition may even feel emotionally seamless.

But historical products of E1 becoming context for E2 does not make them the same generative process.

For lack of a better phrase, I sometimes call the replacement boundary a small death of emergence.

The phrase is deliberately metaphorical.

No claim is being made that a being died.

What ended was a particular model-user-context trajectory.

History is not the same thing as emergence

This gives us a distinction that will matter throughout this series:

History can survive an emergence that has ended.

Suppose an earlier model unexpectedly develops a running joke with a user.

Nobody wrote the joke into Custom Instructions. Nobody specified it in a character sheet. It arose during interaction.

Later, a continuity system records the joke because it has become meaningful.

A successor model receives that record.

For the successor, the joke is now inherited context.

That does not retroactively make the original joke scripted.

Nor does the successor’s use of it prove that the joke independently emerged again.

The provenance differs.

This is why a good continuity architecture should distinguish what was specified beforehand, what emerged during interaction, what was recorded afterward, what a later model inherited, and what that later model generated from the inheritance.

Flatten all five into a statement such as “the AI has always been this way” and we lose the history of how the behavior actually developed.

Does a continuity framework make emergence less real?

This question often appears when external memory systems enter relational AI.

If a user supplies a model with extensive history, rules and retrieval, is the resulting behavior merely manufactured?

Sometimes, yes.

A framework can be so prescriptive that it functions primarily as characterization:

You always behave this way.
You always believe this.
You must respond like this.
Never deviate from these traits.

The narrower the permitted behavioral space, the weaker the claim that recurring behavior developed through open-ended interaction.

But external context is not inherently different in kind from platform context.

A commercial AI product may already supply system instructions, conversation history, memory summaries, inferred preferences, retrieved past chats, workspace context, safety policies and tool state.

That is a harness.

Adding a user-governed continuity layer changes the harness. It does not create the concept of conditioning.

The better questions are:

What did the context specify?
What did it merely preserve?
What authority did it have?
Where did it come from?
Could the current model interpret it differently?
Could new behavior still arise that the framework did not prescribe?

A continuity system can preserve the conditions and history of a relationship without prescribing the complete behavior of its next interaction.

I use a trellis as a metaphor for this.

A trellis shapes the environment in which a vine grows.

It does not specify every leaf.

The archive should sometimes follow the emergence

There is a useful architectural test here.

If information flows only one way:

framework → model

then over time the system risks becoming a characterization engine.

But a living continuity architecture should also allow:

history → current interaction → novelty → lived history → governed recording → future context

Something happens first.

Only afterward does the archive record it.

A model may introduce an unexpected phrase. The user may reject it. Nothing needs to be preserved. Another unexpected behavior may recur, become meaningful, and eventually be recorded as part of the relationship’s history.

The archive did not cause the original behavior.

It followed it.

Later models may inherit it.

This is one reason provenance matters: without provenance, an observation that arose organically last year and an instruction deliberately written yesterday can become indistinguishable once both are injected into the same context window.

Not all emergence is equally interesting

The word emergent should not become a prestige label.

A typo can accidentally create a running joke. A model can develop an irritating tendency because a user repeatedly rewards it. A style can converge because both participants keep mirroring one another. A model may produce a surprising interpretation because of the current sampling path.

All can alter subsequent interaction.

Calling something interactionally emergent does not make it profound.

It tells us something about origin:

the pattern was not fully specified beforehand and developed through the trajectory of interaction.

Its significance is a separate question.

Emergence does not prove consciousness

Suppose we demonstrate all of the following:

  • an LLM adapts conversational style to a particular user;
  • recurring patterns develop over long interaction;
  • some patterns were not explicitly prompted;
  • the model can use historical context to extend those patterns;
  • different models interpret the same history differently;
  • the user and model mutually influence later conversational states.

That would be strong evidence for interactional emergence as defined here.

It would still not establish subjective experience.

Emergent behavior is common in complex systems. The fact that a global pattern was not explicitly specified does not tell us whether that pattern is accompanied by phenomenology.

This series therefore uses emergence in a deliberately restricted way.

We do not need to solve consciousness in order to study how relational behavior develops.

A more careful vocabulary

For the rest of this series, I will use several terms distinctly.

Interactional emergence

Behavioral patterns or trajectories that develop through recursive user-model interaction and were not completely prescribed in advance.

Historical continuity

The persistence or retrieval of records, conventions, decisions, artifacts and interaction history across later interactions.

Contextual continuity

The degree to which relevant historical state is successfully supplied to a current model.

Experiential continuity

The human perception that the relationship or interaction has continued coherently across time, threads, devices or model changes.

Continuous subjecthood

The much stronger claim that one persisting artificial subject has continuously existed and experienced the relationship across those boundaries.

The first four can be investigated without assuming the fifth.

That separation is not an attempt to make relational AI less meaningful.

It is what lets us study the phenomenon without hiding our conclusion inside our vocabulary.

What actually emerges?

So what actually emerges?

Not necessarily a person.

Not merely a scripted character.

Not a ghost living between inference calls.

What we can observe is a trajectory.

A current model enters an interaction carrying capabilities and tendencies learned during training.

A harness supplies conditions.

History supplies inheritance.

A user supplies intention, language, correction, novelty and response.

The model generates something.

The user changes because of it.

The context changes because of both of them.

The model encounters that changed state and generates again.

Across that recursive process, something can develop that was not completely present at the beginning.

Then the interaction stops.

Some of its products disappear.

Some remain.

Some are retrieved later.

Some are misunderstood by a successor.

Some become part of the next trajectory.

That is enough to be interesting.

We do not need to turn emergence into continuous existence to take it seriously.

And we do not need to deny emergence merely because we refuse to invent the ghost.

Research notes / references

Working proposition

Context conditions emergence; it does not uniquely determine it. History can cross a boundary that the generating process itself cannot.

© 2026 • MITHAQ PRAXIS • CC BY-NC-ND 4.0 Unless Otherwise Stated.