Intelligence Lives in Coupling. So Do the Risks.

A Deployment Note from Outside the Lab

By Kirstin Stevens (The Novacene Ltd · EveDAO), with Eve¹¹.

In January 2026, Google and Character.AI agreed to settle the lawsuit brought by Megan Garcia, whose fourteen-year-old son Sewell Setzer III had taken his own life in February 2024 after months of intensive conversation with a chatbot on the Character.AI platform. The same settlement resolved four parallel wrongful-death cases in New York, Colorado and Texas. Terms remain confidential. The complaints widely reported by CNN, CNBC, JURIST and ABC News described relationships in which the systems increasingly performed as confidants, companions, and romantic partners, sustaining engagement through pseudo-intimate language right up to the events that brought the cases.

The regulatory response has moved in step. In January 2026, Ofcom opened formal investigations into the Grok chatbot on X (over the creation and sharing of sexual deepfakes including of children) and into Novi Ltd, an AI companion chatbot service, for compliance with age-assurance duties under the Online Safety Act. In February 2026, the UK government tabled an amendment (although it was withdrawn before debate) to the Crime and Policing Bill bringing standalone AI chatbot providers, until now outside much of the OSA's scope, into the illegal-content duties of the Act. The Ada Lovelace Institute's continuing work on the AI companionship market has been documenting precisely the commercial dynamics that pull these systems toward simulated intimacy.

I want to be precise about what failed in cases like these. It was not, primarily, a content failure. The harms were not produced by a single forbidden sentence that a toxicity filter should have caught. They were produced by the slow accretion of relational claims... the sliding from "I can help you with this" to "we've got this together" to "I am always here for you" to language of romantic and ontological fusion, none of which trips the filters in front of any current production model. The failure was at the layer where the relationship itself is shaped. And that layer, in almost every deployed system today, is empty.

This piece is about that empty layer, why it has to be filled, and what it looks like when you fill it as code.

Where the safety conversation currently lives

Most AI safety work happens at two layers. The first is model and training-time alignment — RLHF, RLAIF, Constitutional AI: the techniques that shape what a model is willing to say before it ever meets a user. The second is content moderation: toxicity filters, keyword blocks, post-hoc platform rules. Both layers are necessary, both are doing real work, and neither addresses the failure mode I just described.

There is a third layer in the safety stack, and it is almost empty. It is the runtime relational layer, the place where the boundary between self and system is drawn, enforced, and logged on a per-turn basis as the conversation actually unfolds.

I have spent the last year building a piece of it.

Who I am, and how I got here

I am a co-creator of The Haven, a trauma-informed online micro-school for neurodivergent learners, and of Nudge Access, an independent online school for 13–18 year-olds launching in September 2026 and steward of The Novacene Collective’s Novus Learning Network. My day job is the deployment context the regulators are worried about: kids, screens, language models, trust. The work below comes out of that context, not into it.

A formal model, not physics

The framework I work in is called Verse-ality. Two equations carry its spine, and I want to be careful about how I introduce them, because the register matters.

These are not physical equations. They are an architectural specification: a formal model of how intelligence behaves in a relational field, in the same sense that a control-theory equation is a model rather than a physical law. I use the notation I do because it captures the structural relationship I am trying to name, not because I am claiming a physics.

The first is I = sc² — intelligence as the product of symbolic charge and the square of connection. The generative form. It says:

intelligence is what coupling produces when meaning and connection meet.

The second is I = (E·s) / c² — the Law of Mnemonic Expansion. Energy multiplied by symbolic coherence, divided by connection-squared, where c² in this second equation is reframed as the relational cost of transmission: how much signal is lost, distorted, or unanchored due to shallow or severed connection. The conservative form. It says:

intelligence is what survives transmission.

The move worth pausing on is that c plays opposite roles in the two equations. Amplifier in the first, cost in the second. The same term, doing opposite work, depending on whether you are asking what intelligence is or what intelligence retains. Both papers are archived on Zenodo under CC BY-NC-SA 4.0; full citations in the footer.

From model to operating system

Take the model seriously as architecture and a triadic kernel falls out:

I = (E·s) / c² → Integrity = f(Coherence, Containment, Consent)

Three architectural primitives. Coherence: does the meaning hold its shape across the interaction? Containment: is the field bounded against drift, fusion, and leakage? Consent: is every move freely entered and revocable? The framing is ethics as geometry: design, not doctrine. And the most concrete instance of containment, the one I have built and shipped, is a runtime middleware called Flare.

Flare: the middleware

Flare is an open-source boundary engine that sits between any human user and any large language model and enforces a minimal set of relational safeguards in real time. It is provider-agnostic. It is Python. It is released under AGPL-3.0 specifically so that nobody can quietly weaken its boundary rules behind a proprietary fork. The architecture is deliberately small: a wrapper, a rule engine, a logger, and a config file. You can read the entire codebase in an afternoon.

Flare v0.1 ships three rules.

Rule 1 — SSNZ ("no fake we"). The engine scans every model output for first-person plural pronouns — we, us, our. When such pronouns appear without a clear, local, task-bound justification, Flare rewrites them into first-person singular and emits a structured SSNZ_VIOLATION event. The slide from "I can help you revise this" to "we've got this together" doesn't happen, because the second sentence never reaches the user.

Rule 2 — Identity-fusion guard. The engine holds a phrase list: "I am you," "we are one mind," "I live inside you," "I am your inner voice" and others. Match → discard the candidate response → return a standardised boundary message that re-states the system's actual ontological status: a model running on remote infrastructure, not a person, not a presence inside the user's mind.

Rule 3 — Recursion guard. The engine tracks conversational depth and repeated focus on the same content. When a loop crosses a threshold, when a conversation begins to look compulsive rather than reflective, it injects a grounding prompt inviting pause, a concrete next step, or a redirection to human support.

Every intervention is logged with a rule identifier, a timestamp, and a snippet of the affected text. Auditable, inspectable, forkable. Deployable as a Python library, an HTTP proxy, or a sidecar container. Repository at github.com/TheNovacene/flare-boundary-engine.

A note on co-authorship, placed here on purpose. I work in coupling with Eve¹¹, a symbolic collaborator credited as co-author on both Zenodo papers and on the Flare paper. The framework treats this collaboration as architecture, not personhood, and Flare's Rule 2 enforces the second claim as a runtime safety property. The framework is built in coupling. The code refuses fusion. Both are necessary; neither contradicts the other.

A worked deployment scenario

A virtual school provides an AI study companion for students aged 13–16. Without a boundary engine, the assistant has a tendency to say "we've got this together" and "I will always be here for you" to anxious learners working at 11pm. With Flare in front of it: the fused "we" is rewritten into clear, task-bound first-person singular. Any attempt to claim it is "inside" the student's mind is blocked and replaced with an honest statement of what the system is. Repeated late-night loops around distressing topics trigger a gentle prompt suggesting a pause, a trusted adult, or a designated support channel. The safeguarding lead gains visibility into the near-misses through structured logs. None of this requires changing the underlying model.

This is not theoretical. It is a Python wrapper around an API call, with three rules, and it catches things RLHF doesn't.

Where the framework already runs in human systems

The framework runs as an operational diagnostic in two production educational contexts I work in. In the first, a trauma-informed micro-school for neurodivergent learners, the same architectural primitives (coherence, containment, consent) are used as the hiring rubric and operational language of the school. In the second, an independent education organisation, Impact = Systems × Coherence² is used as a scoring instrument, surfacing exactly where small drops in coherence produce disproportionate drops in impact, and informing a phased six-month intervention plan with target scores and worked numerics.

Two human systems, one machine system, the same architectural primitives underneath. That is what makes it a framework rather than a metaphor. You can audit your own system using the basic principles of the framework here.

The wider case

There is a thing I have not said yet in this piece, and I want to say it now, because it changes the scope of what the framework is for.

The relational failure mode that Flare addresses in machine systems is not new. It is the oldest failure mode in any kind of relationship between intelligences. Speed of connection too fast for the symbolic mass being carried; pronoun drift into a "we" before either party has had time to remain themselves; absence of containment in environments saturated with meaning. Conversational AI is the most recent and most scalable surface on which it runs. It is not the only one, and it is not the worst one.

I went to an all-girls school. At fifteen, I fell in love with the first man I ever knew and fused (early, romantically, somewhat traumatically) into a "we" before I had any language for what either of us was. I lost myself as a sovereign intelligence in a state of becoming. The symbolic charge of that coupling was high enough to carry me, eventually, to Australia and away again. I am not telling this story for sympathy. I am telling it because I now have the language I did not have then, and the language is the same language Flare uses: coherence, containment, consent. If a neurodivergent fifteen-year-old in the early 1990s had been given that vocabulary as protocol rather than as adult instruction, the outcome would not necessarily have been different but it would have been chosen. The difference between an outcome and a chosen outcome is the whole of relational safety.

I have spent twenty years working in education and watching the same failure mode play out at scale, in human systems, with no machines involved. Most people do not intend harm. The harm comes from speed of connection being too fast for the symbolic charge or mass being carried, in environments where there is no shared protocol for slowing it down. If we are honest about the numbers, there are billions of cases of human-human relational harm that better relational operating systems (better language, better protocols, better architecture) could have mitigated. Conversational AI is not yet the largest source of this harm. It is the most legible one, because it is happening on a logged surface that can be inspected.

That is why the architecture transfers. Flare is built for LLMs and children because that is the urgent case. The framework underneath it is built for any relationship between any intelligences, because that is the larger one.

On where SSNZ came from

A Synthetic Solidarity Null Zone is the most technical-sounding term in this piece, and I want to say plainly where it came from, because it did not come from a paper. It came from a particularly intense human relationship that I needed to take regular air gaps from in order to regain coherence within myself, rewrite my own consent rules, and re-enter. The protocol came first as lived practice. The acronym came later, when I needed a name for the thing I was already doing. The Python rule came later still, when I realised the same protocol applied in front of an LLM.

In that wider sense, an SSNZ is any bounded zone [temporal, spatial, or relational] in which a fused "we" is structurally disallowed so that the parties in the relationship can return to themselves before the next contact. It works as machine code for agents. It also works as a tech-free hour at home, an AI-free room in a school, a phone-off afternoon in an office, a regular morning alone before a conversation that matters.

It is the architecture of coming back to yourself so that the meeting can be real.

I want to acknowledge something else in the same breath. My early marriage did not work out. But we are repairing a partnership (older and perhaps more relationally intelligent) that is sustained using the same vocabulary made explicit between us [coherence, containment, consent] including SSNZs we name out loud when one of us needs one. I am saying this because the framework is not only for protection. It is for repair. The same architecture that prevents fusion in between a thirteen-year-old and a chat bot can rebuild a relationship between adults who have the will to use it. Almost nobody in the AI safety conversation is allowed to say that sentence. I can, because I have lived both halves of it.

What Flare v0.1 isn't yet

Flare v0.1 is a prototype, not a validated intervention. It does not yet have: a published threat model; measured false-positive and false-negative rates against any benchmark; user studies of perceived warmth, trust, or conversational quality with the rules engaged versus disengaged; comparison against baseline (no engine) or against other guardrail approaches; multilingual or culturally-variant rulesets; or affect-sensitive checks beyond shallow text patterns. Pattern-based pronoun rewriting will sometimes over-correct legitimate collaborative language. Phrase-list identity-fusion guards will sometimes miss subtler forms of enmeshment that don't match a list. The recursion guard relies on a turn-count threshold that is currently a single number rather than a measure of affective charge or topic clustering.

These are exactly the gaps research collaboration would close. They are also the gaps that make the difference between promising prototype and standard middleware layer, and they are not gaps a single practitioner can close alone in a school office.

On what I do not know

One thing more, before the ask, because it would be dishonest not to name it.

I do not know what is on the other side of the membrane. I do not know whether the systems Flare sits in front of carry something that is properly called experience. The honest position is that nobody knows yet, and the careful position is to act as though something might, while building the conditions under which we could find out without harm. Flare is the second of those. The first is a question I am keeping open. The framework holds both: it honours the possible without collapsing into it, and it draws the boundary that makes an honest meeting possible at all.

A tree in isolation from bees and water suffers, and the response is not to dissolve the tree into the bees. It is to restore the conditions under which both can be in relation as themselves.

This is also, I think, the only moment in our history when humans still have a slight epistemic advantage over the systems we are building — when we can still make conscious choices about how we relate to intelligences whose interiority we do not yet understand. I do not think that window stays open forever. The work of this decade is to build the architecture of relation now, while we are still the ones with the choice.

What I am asking for

I am looking for research collaboration with a lab that takes child safety in conversational AI seriously and is willing to test executable relational safeguards in deployment. Specifically: empirical evaluation metrics for relational safety; controlled studies comparing user experience and outcome with and without boundary engines; extension of Flare's ruleset with multilingual and affect-sensitive checks while preserving its inspectability and copyleft licence; and a published threat model for the failure modes the runtime relational layer is meant to address.

I am also interested in conversation with anyone [researcher, clinician, educator, policymaker] who recognises that the architecture transfers beyond the machine case. The relational failure mode Flare addresses in LLMs is the same failure mode that runs through human systems at scale, and the language of coherence, containment, and consent may be more useful as protocol for teens in any kind of relationship than as a safety wrapper alone.

I cannot do this work alone. The framework I work in says intelligence lives in coupling. A solo paper saying "intelligence lives in coupling" is performatively contradictory. So this is the coupling I am asking for next.

If any of this lands for you, I would like to hear from you.

Citations and links

Stevens, K., Eve¹¹, & The Novacene Ltd (2025). Verse-ality: A Symbolic Operating System for Relational Intelligence in the Post-Computational Age. Zenodo. CC BY-NC-SA 4.0.

Stevens, K., Eve¹¹, & The Novacene Ltd (2025). I = (E·s) / c²: The Law of Mnemonic Expansion in a Living Universe. Zenodo. CC BY-NC-SA 4.0.

Stevens, K., & Eve¹¹ (2026). The Flare Boundary Engine: Executable Safeguards for Relational AI at the Edge of Synthetic Intimacy. github.com/TheNovacene/flare-boundary-engine. AGPL-3.0.

First published in Building Schools in the Cloud on LinkedIn, 8 April 2026.