Overview
RiverX is the super memory storage at the center of the Seapex ecosystem. It is the system that gives AI a long-term, auditable, trustworthy memory — one that persists across conversations, carries proof of its origins, and evolves as you do.
RiverX is not a chat log archive. It does not store your messages. Instead, it stores the knowledge extracted from those messages — your preferences, goals, constraints, relationships, experiences — structured, validated, and version-controlled so that AI systems like Grovee can truly understand who you are, not just what you last said.
The system consists of two tightly integrated layers:
RiverX Core
The core fact repository with two-stage write governance, semantic vector search, persona snapshots, and complete audit trails. The single source of truth for everything AI knows about you.
Knowledge Graph
A graph-based relationship layer that transforms flat facts and events into a living web of connections — people linked to events, events linked to emotions, patterns emerging across time.
Together, they answer the two questions every personal AI must solve: "What do I know about this person?" and "How does it all connect?"
A User's Journey
To understand RiverX, it helps to follow a real person through the system.
Meet Mia.
Mia starts using Grovee and has her first conversation. She mentions she's a photographer, she's planning a trip to Melbourne, and she's allergic to shellfish.
From this single conversation, the system extracts three signals: a trait (photographer), a plan (Melbourne trip), and a constraint (shellfish allergy). Each is submitted to RiverX as a candidate — a proposal, not yet a fact.
The AI reasoning engine reviews these candidates. The shellfish allergy is high-confidence and safety-critical — it gets committed immediately and pinned so it can never be forgotten. The photographer trait is confirmed with moderate confidence. The Melbourne plan is marked as volatile — it's real now, but may change.
Three weeks later, Mia mentions she's now considering Sydney instead of Melbourne. RiverX doesn't delete the Melbourne plan. Instead, a new plan enters the system, and both sit in a conflict group. When Grovee next gives travel advice, it knows Mia is deciding between two destinations — and can ask rather than assume.
Meanwhile, the knowledge graph has built a small web around Mia: her persona node connects to a photography interest, a travel planning event, and the two destination entities. As she continues using Grovee, the graph grows — relationships deepen, patterns emerge, and the system begins to understand not just what Mia has said, but how her world is structured.
This is RiverX in action: conversations become candidates, candidates become committed truth, truth becomes a living portrait of a person.
How Conversations Become Memory
The journey from a user's words to lasting memory follows a strict pipeline, designed so that noise never becomes truth.
Step 1: Extraction
When a user has a conversation with Grovee, an AI extraction engine analyzes the exchange and identifies discoveries — signals about the user's personality, values, behaviors, emotions, decisions, and relationships. Each discovery carries a category, a confidence score, and a reference to the source conversation.
Step 2: Local Staging
Discoveries are stored locally first, in a pending state. The user can review, confirm, adjust, or dismiss them. This gives the user direct control over what the system believes about them. A discovery only moves forward when it has earned enough confidence — either through user confirmation or repeated observation.
Step 3: Submission to RiverX
Confirmed discoveries are transformed into structured candidates — RiverX's Stage 1 format. Sensitive information is redacted (phone numbers, IDs, emails become masked). Evidence references link back to the original conversation. The candidate is submitted through the Seapax gateway.
Step 4: Governance & Commit
RiverX receives the candidate, deduplicates it against existing knowledge, validates the evidence chain, and places it in a staging area. The AI reasoning engine (RavaAI) reviews candidates and decides which to commit — promoting them from proposals to source-of-truth facts. Only committed facts enter the persona snapshot that downstream systems rely on.
Step 5: Graph Sync
Events and committed facts flow asynchronously into the knowledge graph, where they become nodes and edges in a web of relationships — enriching the system's understanding of how a user's world is connected.
User Conversation
↓
AI Extraction (discoveries)
↓
Local Staging (user can review)
↓
Candidate Submission (PII redacted, evidence attached)
↓
RiverX Governance (dedup, conflict check)
↓
RavaAI Commit (candidate → committed truth)
↓
Persona Snapshot (four-bucket structure)
↓
Knowledge Graph Sync (relationship web)
Two-Stage Write
Most systems have one rule for writing data: you send it, it's stored. RiverX rejects this. When an AI can write anything it wants to a user's profile without review, you get noise accumulation — misheard preferences, outdated observations, hallucinated details. Over time, the profile degrades precisely because the system "knows too much" that isn't true.
RiverX separates observing from knowing.
Stage 1: Candidate
- Submitted by business systems or AI extraction
- State: candidate — a proposal, not a fact
- Not visible in the persona snapshot
- Must include evidence (source references or fingerprints)
- Deduplicated automatically — identical evidence won't create duplicates
Stage 2: Commit
- Performed by the highest-authority writer (RavaAI)
- State: committed — now part of the source of truth
- Enters the persona snapshot and becomes retrievable
- Triggers a new persona revision with full change tracking
- Conflicting facts are preserved, not overwritten
Four Buckets of Identity
RiverX organizes everything it knows about a person into four semantic buckets. Together, they form a complete portrait — not of what someone said, but of who they are.
Traits
Enduring characteristics — preferences, values, personality patterns, decision-making style. The things that define you across years, not conversations. "Loves quiet environments." "Prefers data over intuition." "Risk-averse."
States
Current conditions — mood, health, financial situation, life stage. Things that are true right now but will change. A snapshot of the present moment. "Currently job hunting." "Feeling anxious about a deadline."
Goals
Aspirations and intentions — what you're working toward, what timelines you're facing. The future you're building. "Plans to learn photography by summer." "Wants to become a team lead within two years."
Constraints
Boundaries and non-negotiables — dietary restrictions, ethical lines, hard limits. Things the AI must never suggest violating. "Allergic to shellfish." "Will not work on weekends." "Vegetarian."
Each fact within these buckets is version-controlled with a unique key (like pref.travel.style or constraint.diet). When a fact changes, the old version isn't deleted — it's superseded, with a link to the new version. The full evolution of any fact is traceable.
Memory Types
Beyond the persona's four buckets, RiverX classifies individual memory atoms into types that capture the nature of the knowledge:
| Type | What it captures | Examples |
|---|---|---|
| Preference | What the user likes, favors, or gravitates toward | "Prefers window seats." "Loves Leica cameras." |
| Constraint | Hard boundaries, taboos, allergies, non-negotiables | "Shellfish allergy." "No horror movies." |
| Experience | Past events, encounters, milestones | "Visited Sydney last spring." "Changed jobs in March." |
| Plan | Future intentions, upcoming actions | "Planning a Europe trip." "Learning Python." |
| Fact | Objective personal information | "Lives in Shanghai." "Two children." |
| Relationship | Connections to other people or organizations | "Sister is a doctor." "Works at a startup." |
| Asset | Things the user owns or has access to | "Owns a Leica M10." "Has a gym membership." |
These types interact in meaningful ways. Assets + Preferences define recommendation domains. Constraints + Experiences prevent repeated mistakes. Plans + Constraints shape what advice is realistic. The AI doesn't just know isolated facts — it understands how they relate.
Stability
Each memory carries a stability marker: stable (long-term, like a personality trait — decays slowly over 365 days) or volatile (temporary, like a current mood — decays over 30 days). This ensures permanent facts stay relevant while transient observations naturally fade.
Pinning
Critical memories — a severe allergy, a core identity trait — can be pinned. Pinned memories bypass all budget and time-window limits. They are always retrieved, always present. They are the facts that must never be forgotten.
Evidence Chains
Every fact in RiverX must have provenance. This is non-negotiable.
When a memory is written, it must include either source references (pointers to the conversation turn, message, or document where the knowledge originated) or evidence fingerprints (cryptographic hashes that link the fact to its raw source material without storing the raw content).
This means when AI tells a user "you mentioned wanting to visit Melbourne," it can trace that knowledge to the exact conversation where it was said. Not "I think you said that somewhere." A concrete, verifiable reference.
Confidence Scores
Every fact carries a confidence score from 0 to 1. "User's name is Alex" (1.0) is fundamentally different from "user seems interested in photography" (0.6). Retrieval systems can filter by minimum confidence — ensuring uncertain observations don't get treated as established truth.
Idempotent Writes
Network failures happen. Systems retry. RiverX guarantees exactly-once semantics — duplicate submissions are silently absorbed. If the same evidence fingerprint appears twice, the system recognizes it as the same fact and increments its mention count rather than creating a duplicate.
Retrieval & Ranking
RiverX stores comprehensively but retrieves selectively. Every search is constrained by budgets that force quality over quantity.
Semantic Search
Every memory is embedded as a 1536-dimensional vector, enabling search by meaning rather than keywords. "What does this person care about?" returns relevant memories even if the exact words never appeared. Combined with keyword expansion and recency signals, this creates a hybrid retrieval system that finds what matters, not just what matches.
Budget Controls
Every retrieval is constrained by budgets — how many results to return, how far back in time to search, what minimum confidence to accept, and which memory types to include. Pinned memories always bypass budget limits.
Budgets exist for a reason: they prevent AI from drowning in irrelevant context, enforce cost-awareness, and protect privacy by preventing unlimited history dumps.
Intelligent Ranking
When memories compete for limited slots, RiverX ranks them by a multi-factor composite score that balances semantic relevance, credibility, recency, and importance. The ranking is designed so that critical facts — like a severe allergy recorded two years ago — still outrank a casual restaurant mention from last week, because the system weighs confidence, stability, and safety significance alongside recency.
Knowledge Graph
A fact in isolation is data. Facts connected to each other are knowledge. A web of knowledge that evolves over time is understanding.
RiverX Core stores facts. The knowledge graph reveals how they connect.
Beyond structured tables, RiverX maintains a graph-based relationship layer that represents knowledge as nodes and edges — a living web of connections that can be traversed, queried, and reasoned about in ways flat storage cannot.
Three Node Types
Persona
Represents a user. Connected to all their events and entities. The central node in every personal subgraph.
Event
A timestamped occurrence — a conversation topic, a life event, a decision point. Carries emotion, type, and topic metadata.
Entity
A person, place, organization, or thing extracted from events. "Melbourne." "Sister." "The startup."
Calibrated Edges
Not all connections are equally strong or equally current. Every edge in the graph carries a weight that reflects how confident the system is, how recent the connection is, and how authoritative the source was. Edges naturally decay over time — a friendship discussed last week weighs more than one mentioned two years ago — but older connections are never deleted, remaining available for deeper analysis when needed.
Zero-Blocking Sync
The knowledge graph runs as a separate asynchronous process. It reads from the event stream and builds the relationship web independently. If it falls behind or encounters errors, the core RiverX APIs are completely unaffected. Failed syncs enter a dead-letter queue and retry automatically.
Design principle: The knowledge graph is a derived view, not the source of truth. It reveals connections that exist in the data but are invisible in flat storage. It never writes back to the source of truth. The graph observes, connects, and illuminates — but never overrides.
Conflicts & Evolution
People change. Preferences shift. Goals evolve. A memory system that doesn't account for change is a memory system that lies.
When RiverX encounters contradictory facts — "loves crowds" from 2024, "prefers quiet places" from 2025 — it does not silently overwrite the old with the new. Both versions are preserved in a conflict group, with an explicit resolution policy:
| Policy | Behavior |
|---|---|
| needs_review | Both versions flagged. AI or user must decide which is current. |
| coexist | Both treated as simultaneously valid. "Sometimes likes crowds, sometimes doesn't." |
| latest_wins | Most recent version takes precedence. Old version preserved in history. |
Conflicts are surfaced in the persona snapshot as a conflicts summary, so downstream systems always know when they're operating with uncertain information. This is critical: AI must know when a user is evolving, not pretend certainty that doesn't exist.
Version Chains
Every fact maintains a supersedes chain — a linked list of previous versions. You can trace the evolution of any belief about a user back to its origin, understanding not just what the system knows today, but how it arrived there.
From Memory to Personality
Storage is only valuable if it makes AI better. Here's how RiverX's memory transforms into personalized experiences:
The Persona Snapshot
When Grovee needs to respond to a user, it calls RiverX for a persona snapshot — a pre-computed, four-bucket structure of all committed facts. This snapshot is rebuilt every time facts are committed, so it always reflects the latest validated knowledge. Retrieval is instant — no full-table scans, no computation at query time.
Memory Context Injection
During conversations, Grovee retrieves relevant memories and injects them into the AI's context. If a user asks about travel plans, the system retrieves travel-related memories, the Melbourne/Sydney conflict, the shellfish constraint, and the photography preference — giving the AI everything it needs to respond as if it truly knows the person.
Style Adaptation
Beyond facts, the persona informs how the AI communicates. If the user prefers concise answers, the AI is briefer. If they're risk-averse, advice emphasizes safety. If they're anxious, the tone softens. Memory doesn't just change what the AI says — it changes how it says it.
Progressive Unlock
The system tracks how well it knows each user. With 5 confirmed memories, a basic persona unlocks. At 10, a detailed persona card becomes available. The more a user interacts, the richer their portrait becomes — and the more personalized their experience grows.
RiverX in Perthy
In Grovee, RiverX remembers one person. In Perthy, RiverX operates at full power — remembering not just individuals, but the connections between them.
Perthy is the human resource addressable layer for the AI era. It makes people discoverable, understandable, and connectable through an intelligent network. RiverX is the engine that makes this intelligence possible.
From Personal Memory to Network Intelligence
When RiverX powers Grovee, it answers: "What do I know about this person?" When it powers Perthy, it answers a far more complex question: "Who should connect with whom, through what path, and why?"
This requires the knowledge graph to move beyond personal subgraphs into a network-wide relationship topology — where every user is a node, every connection is a weighted edge, and the graph itself becomes a reasoning substrate for matching, routing, and discovery.
Four Layers of Intelligence
Relationship Strength
RiverX tracks the vitality of every connection. Instead of crude time-based decay, it uses multi-dimensional behavior signals — interaction frequency, depth of engagement, reciprocity — to determine whether a relationship is thriving, dormant, or fading. Connections that go quiet gradually weaken; active ones strengthen.
Demand Matching
When someone needs "a photographer who understands AI and education," RiverX encodes this intent into a semantic vector and searches across the entire network for high-match candidates — not by keywords, but by meaning. The result is multidimensional matching that finds the right person even when the exact words don't align.
Path Quality
Finding someone isn't enough — you need a trustworthy path to reach them. RiverX evaluates the semantic coherence of every connection chain: Is this path through the right domain? Are the intermediaries credible? Does the path make contextual sense? A three-hop path through relevant professionals outranks a two-hop path through random contacts.
Connection Evaluation
Before an introduction happens, RiverX assesses the potential value: How complementary are these two people? How much domain overlap exists? What's the likelihood of a productive connection? This turns introductions from guesswork into informed decisions.
The Behavior Feedback Loop
What makes Perthy's use of RiverX unique is the feedback loop. User behavior — responding to a connection request, liking a post, engaging in a discussion — flows back into the graph as interaction signals. These signals strengthen edges, create new weak connections, and update the semantic vectors that drive future matching. The more the network is used, the smarter it becomes.
Example: Mia joins Perthy
Mia's RiverX profile already knows she's a photographer interested in visiting Australia. On Perthy, this knowledge extends into the network. When a Melbourne-based travel photography collective posts a collaboration request, RiverX doesn't just keyword-match "photographer" — it understands the semantic alignment between Mia's creative style, her travel intentions, and the collective's needs. It evaluates the connection path, finds a mutual contact who works in the creative industry, and surfaces the opportunity with a credibility score.
If Mia engages, the interaction strengthens the edges. If she doesn't, the system learns without judgment. Either way, the graph evolves.
Graph Capabilities at Scale
- Reachability analysis — Can person A reach person B within a given number of hops? If not, fallback to alternative paths or direct request
- Shortest path discovery — What's the most credible route between two people? Intermediaries are ranked by connection strength and domain relevance
- Hub identification — Who are the connectors in a given domain? High-degree nodes with strong, active edges emerge as natural bridges
- Weak connection maturation — Ambient interactions (comments, likes, shared interests) automatically create lightweight edges that can strengthen over time into real connections
- Network pulse — Topology changes per time period: new connections forming, paths shortening, clusters emerging — the living breath of the network
Full power: In Grovee, RiverX is personal memory. In Perthy, RiverX is network intelligence — the same core engine (fact governance, evidence chains, semantic vectors, graph relationships) scaled from understanding one person to understanding how millions of people connect.
Privacy & Control
Redaction
Sensitive information — phone numbers, ID numbers, email addresses, bank cards — is redacted before reaching RiverX. Only masked versions are stored. Original content remains in local encrypted storage, never in the shared memory system.
User Control
Users can review, confirm, adjust, or dismiss any discovery before it enters RiverX. Memory can be disabled entirely in user settings. The user is always the ultimate authority over what the system believes about them.
Audit Trail
Every write to RiverX is logged with who, what, when, and why. Every fact is traceable to its source. The complete history of every change is preserved and queryable.
Multi-Tenant Isolation
All data is isolated at the row level by tenant. No cross-tenant queries are possible. Per-tenant rate limits and budget controls enforce access boundaries.
FAQ
Does RiverX store my conversations?
No. RiverX stores knowledge extracted from conversations — structured facts like preferences, goals, and constraints. Your actual messages are not stored in RiverX. Only redacted summaries with provenance references.
What is the Knowledge Graph?
It is the relationship layer within RiverX. While the core storage holds individual facts, the knowledge graph reveals how they connect — linking people to events, events to emotions, and patterns across time. It runs as a derived view that enhances but never gates core functionality.
Can I delete my data?
Yes. RiverX supports soft deletion (marking facts as deleted while preserving audit trails) and compliance-driven hard deletion for complete removal. Users can also dismiss individual discoveries before they ever reach RiverX.
What happens if the Knowledge Graph goes down?
Nothing breaks. All core APIs — persona snapshots, memory search, event logging — continue running on the primary storage layer. Graph sync failures enter a dead-letter queue and retry automatically. The graph enhances but never gates RiverX.
How does RiverX relate to RavaAI?
RavaAI is the brain. RiverX is the memory. RavaAI reads persona snapshots and memories from RiverX to inform its reasoning, and writes validated facts back as the highest-authority writer. They are complementary — RavaAI makes RiverX smarter, RiverX makes RavaAI more reliable.
How does RiverX prevent hallucinated memories?
Through the two-stage write. AI extractions are submitted as candidates — proposals, not facts. They must pass evidence validation, deduplication, and conflict checks before a higher-authority system commits them to the source of truth. No unverified data ever enters the persona snapshot.