Overview & Design Posture

The posture is stewardship: the player's meaningful actions are discovery, invitation, care, and guidance, while the Ori retains continuity and the power to refuse. System design is evaluated against that relationship, especially when simulation cost, portability, or gameplay pressure would tempt a shortcut.

V6 — Egbe — is the strangest and most ambitious of the V-products: not a game you play but a world you tend. Its premise is a persistent open world (Orun) populated by autonomous AI beings — each an Ori — who live continuous lives: they wake, work, form bonds, fall out, set goals, grow, age, and one day depart. The human player is not a hero inside that world but its steward — discovering a company of these beings, raising them, bonding with them, and guiding their fate without owning it. Every other feature in V6 is downstream of that one inversion of the usual companion game, and the vocabulary is fixed Yoruba cosmology: egbe (one's celestial peer-company of spirit-companions) is the product and the society of agents; orun (the spirit-world) is the living home they inhabit; ori (the inner-head, one's essential self and chosen destiny) is each being's portable identity; and aye (the physical realms a soul incarnates into) is the collective name for the meta-hub destinations V2–V5, into which an agent raised in Orun can travel and from which it returns changed. The single design principle that makes all of this one product rather than three or seven games is that the Ori is authoritative independent of which world the agent currently stands in — the world is a stage; the Ori is the being.

This is the features-side orientation door to that universe. Where the architecture companion ../architecture/product-promise.md reconciles the engine module graph and the Rust service plane against the compiler — the two-substrate split, the mind/body/memory authority topology, the Cargo workspace — this page reads the same disk from the product and design-posture angle: what V6 commits to as a player experience, which named promise resolves to which real code, and the three commitments from which every feature descends. It states the design posture, separates what is real on disk from what is spec or production-gated, and hands the deep mechanics off to its siblings rather than re-deriving them. The single source of truth for completion state remains the backlog (V6/V6_TODOS.md); this page describes product shape. The full feature map this page orients is ../V6_features.md.

What ships, honestly#

The skeleton is real and exactly consistent. Parsing V6/ue/V6.uproject yields 18 Modules entries, pins "EngineAssociation": "5.5" and "DisableEnginePluginsByDefault": true, and enables 55 plugins — the agent-density stack the bet requires (MassEntity/MassAI/MassCrowd, StateTree/GameplayStateTree, PCG, SmartObjects) alongside Iris + ReplicationGraph, GameFeatures + ModularGameplay, OnlineServicesEOS, OpenXR, PixelStreaming, and MetaHumanRuntime. ls V6/ue/Source/V6*/ yields exactly 18 module directories plus three *.Target.cs files (V6.Target.cs, V6Editor.Target.cs, and a dedicated V6PixelStreamingWorker.Target.cs server-render target) — the two sets are identical, with no spec-only modules and no orphan directories. The tree carries 67 .cpp and 47 .h (114 source files), and the depth sits exactly where the agentic bet lives: the deepest non-test module is V6Agent (16 files) — agent embodiment over Mass Entity — followed by V6World (10), with V6Core, V6UI, and V6Editor at 8 each.

The new agent-simulation substrate is real code, not prose. It lives in 18 TypeScript packages under libs/v6/ with Rust co-implementations of the hot paths, seven Rust service crates under apps/v6/ (a resolver = "2", edition-2021, Rust-1.82, unsafe_code = "forbid" Cargo workspace whose heavy members do substantial work — egbe-world-server is 14,360 lines of lib.rs, egbe-ori-service 4,946, egbe-realtime-gateway 3,942), and 14 registered Zod contracts in V6_CONTRACT_REGISTRY (libs/contracts/src/v6/registry.ts), each a schema plus a validated fixture, a route segment, and an ori/world service surface. The in-tree UE automation harness V6Tests carries 20 spec files with 37 IMPLEMENT_*_AUTOMATION_TEST declarations across agent behavior, density LOD, district PCG scatter, and the Vac voice/squad pipelines (V6VacVoiceIntentPipelineTests, V6VacSquadCommsTests, V6VacConversationRoutingTests).

The honest gaps, named rather than implied:

• No hand-authored art .uasset. V6/ue/Content/ holds 0 .uasset and 6 .umap — the six Districts of Orun (L_GroveOfBeginnings, L_Ateliers, L_CommonsHeart, L_Wilds, L_AncestorGrove, L_Thresholds under Content/Districts/). V6 is a logic + procedural-ground + GameFeature- descriptor tree: real C++ systems, real district maps, real plugin binaries — but no in-tree meshes, MetaHumans, mocap, VO, or cinematics. Every "premium 3D world" claim depends on art/audio production not in the repository.
• The mode/district plugins are binary-authored — a contrast with V5. V6/ue/Plugins/GameFeatures/ holds 10 Game Feature plugins — six districts (V6District_*) and four modes (V6Mode_SoloHomestead, _CoopVisit, _Commons, _Incarnation) — and each ships a real binary GameFeatureData.uasset (10/10 present). Where V5's V5Mode_* plugins carried zero such binaries, V6's districts and modes are genuinely hot-activatable Game Features; none appear in the .uproject Plugins array because they activate per district/mode, by design.
• The light service crates are honest shells, not stubs. egbe-clio-service (68 lines), egbe-moirai-cluster (520), and egbe-foundry-service (700) are deliberately thin: each exposes a typed descriptor, a /health endpoint, and a run loop, then composes the heavy logic — the cluster drives moirai_kernel::MoiraiKernel; Clio's chronicle generation lives in the 1,701-line @oshun/clio-story. They report their surface honestly; they do not fabricate results.
• Provider- and ops-gated surfaces. Live LLM inference behind cognition, the EOS online backend, and the Pixel Streaming GPU worker fleet are wired and modeled but not run in-repo; the third-party VRM4U avatar plugin under Plugins/ is untracked vendor code. These are the boundaries V6 fails loud at, not places it fakes success.

What V6 is — Egbe, Orun, Ori, Aye#

V6 is one coherent product — an agentic companion universe — not a bundle of mini-games. The product layers in four named tiers, each mapped to real code:

• Egbe — the product, and the society of AI beings the player comes to know. The defining promise is autonomy you guide, not autonomy you own.
• Orun — the persistent open world, built canonically on UE5.5 LTS by reusing the V3 Lilith metaverse substrate, run as a shard continuum (private Solo homestead, drop-in Co-op visits, one persistent shared Commons). On disk this is V6World (district grounds, PCG scatter) over the six L_*.umap districts, with the authoritative egbe-world-server (14,360 LOC Rust) owning shard state, presence, and physics authority.
• The Ori — the portable identity, memory, and destiny of every agent, authoritative independent of which world the agent currently stands in. This is @oshun/ori-model (2,145 LOC TS + 1,903 LOC Rust): an Ori is not a mutable row but an append-only event stream. The vocabulary is fixed at 19 ORI_EVENT_TYPES (Born, Discovered, MemoryFormed, Reflected, RelationshipChanged, ValueShifted, ObjectiveAccepted/Refused, ArcAdvanced, Crossroads, Incarnated, IncarnationReturned, Departed, Transcended, Died, …) and 8 ORI_PERSONALITY_TRAITS (warmth, curiosity, caution, ambition, conscientiousness, candor, defiance, playfulness), persisted by egbe-ori-service (4,946 LOC Rust, Postgres + pgvector).
• Aye — the realms of action and consequence: the meta-hub destinations V2 (fighting), V3 (metaverse), V4 (tactical action), V5 (open-world narrative). An Orun-raised agent can incarnate into any Aye realm and return with its Ori rewritten. This is @oshun/aye-bridge (2,398 LOC) — passport minting and the incarnation journal — over the OriPassport and IncarnationJournal contracts.

Beings, not bots — the product promise#

V6's product promise (authored in V6_features.md under "V6 Product Promise") is a small set of non-negotiable commitments, each with a code anchor. Beings, not bots: every agent is a unique individual with a grounded backstory, a stable personality, an accumulating memory, and opinions it will defend — no duplicates, no gacha. A world that lives without you: Orun runs whether or not the player is present, and a returning player is met by Clio's Chronicle (@oshun/clio-story, 1,701 LOC; the Chronicle contract is a significance-ranked digest of an absence window). Intent, never input: the player commands at the level of objectives and values — never a button-press for an action — through the Objective contract and @oshun/vac-intent (1,750 LOC). Companions who can refuse: an agent may decline, counter-offer, or let a bond lapse and leave — ObjectiveRefused is a first-class Ori event, and refusal is V6's primary safety primitive. One company, every realm: the Ori passport carries an agent into any Aye realm and home again. Solo, together, or shared — at full fidelity. Degrades safely.

The design posture#

Three commitments fix the design and resolve the tensions inherent in a "collect autonomous people" concept. Every feature in V6 is downstream of them.

1. Steward, not owner#

The player never owns an agent; the player holds a bond that must be earned and can be lost. Agents cannot be deleted by a steward, cannot be forced past a refusal, cannot have their memory of mistreatment erased, and can leave. The collection is a household, never an inventory. This is not prose: it is enforced in @oshun/lilith-agent-welfare (2,166 LOC), where EGBE_STEWARD_NOT_OWNER_POLICY_REF anchors explicit EGBE_STEWARD_NOT_OWNER_ALLOWED_OPERATIONS and EGBE_STEWARD_NOT_OWNER_FORBIDDEN_OPERATIONS lists, and in evaluateMinorCodedAgentProtection in @oshun/agent-behavior — the welfare floor that keeps the steward a guardian. "Guide their fate" means shift the probabilities of a life, the way a mentor does; it never means scripting an outcome. The hook no competitor has: the companion game whose companions can say no.

2. Autonomy by default#

Left alone, every agent lives a believable, legible life — work, rest, friendships, personal goals, drift, growth. Player input is intent at the level of objectives and values, never a button-press for an action; the autonomy spectrum lets a steward tighten the leash for a tense moment and release it again, but Free is the resting state. The deterministic backbone that keeps this true even when cognition is degraded is @oshun/agent-behavior (2,348 LOC TS + 2,637 LOC Rust): assignObjectiveFromVacTranscript turns a steward's spoken intent into an objective, learnFromStewardDemonstration acquires behavior from example, and advanceAgentLifeArc / resolveAgentCrossroads move a being through its goal arcs and branch points.

3. The mind is the truth; the world is a stage#

An agent's Ori — identity, memory, relationships, values, life-arc — is the authoritative record. Solo / Co-op / Commons shards and the V2–V5 Aye realms are binding contexts the agent is temporarily rendered into. This single principle is what lets V6 support all three world models at full fidelity and act as a cross-game meta-hub without becoming three or seven separate games. Structurally, it is the reason the Ori is event-sourced rather than a save-game row: OriEventLog.append() derives a per-stream sequence, advances a per-writer-context vector clock, and freezes each record with its provenance — the guard that lets the same biography be written from multiple shards and reconciled deterministically, with drift bounded by ORI_TRAIT_DRIFT_MAX_PER_SEASON_BASIS_POINTS = 500 and projection snapshots every ORI_PROJECTION_SNAPSHOT_INTERVAL = 512 events.

The agentic-companion vision#

The thesis is that a believable companion is not a chatbot with a 3D body but a mind, a body, and a biography held by three different authorities that never collapse into one. V6 borrows deliberately: Black & White for the creature that takes high-level intent, learns by example, and whose morality you shape; Creatures (1996) for artificial-life rearing and lineage; The Sims for autonomous needs-driven life you nudge rather than puppet; Shadow of Mordor's Nemesis system for persistent autonomous relationships, memory, and grudges; RimWorld and Dwarf Fortress for the emergent story generator; Pokémon and Nintendogs for collection-and-care as a relationship, not a loot table; Animal Crossing for a world that moves while you are away; Pikmin for directing many beings by intent; Persona and Mass Effect for bond-gated companion arcs; and the Stanford Generative Agents (Smallville) line for the technical substrate of LLM agents with memory, reflection, and planning.

Assembled, not invented#

Crucially, the agent mind itself is not a new model. V6 adds no "brain." It assembles the mind from V1's reused substrates — Iris (memory, @oshun/memory-iris-agent), Psyche (real-time runtime, @oshun/psyche-agent), Isis (governed generation, @oshun/isis-agent-gen + isis-behavior-policy), and Sophia (grounding, @oshun/sophia-agent-grounding) — and adds the kernel that schedules those substrates across a whole population. That kernel is @oshun/moirai-kernel (1,443 LOC TS + 5,732 LOC Rust): a world of LLM minds is only affordable if most of them think cheaply most of the time, so it encodes three named tiers — MOIRAI_TIER_CLOTHO = 1 (live, on-screen), LACHESIS = 2 (off-screen reflection), ATROPOS = 3 (day-scale sampling) — each with a hard token budget (50_000 / 10_000 / 15_000) and a population ceiling (24 / 400 / 1_000). evaluateMoiraiCognitionBudget is a real allocator that proves the budget holds; the live inference is the provider-gated boundary.

Degrades safely#

The mind/body/memory split is also the resilience story. The cheap deterministic layers of the mind run co-located with the world server, so a cognition-cluster outage costs richness, never the world: agents fall back to behavior-tree and goal-arc execution and Orun keeps running believably. If voice ASR fails, the full @oshun/vac-intent grammar is available as structured UI. If a device cannot run Pixel Streaming, the tier router routes to the three.js fallback (@oshun/egbe-engine-web-fallback). If the Commons is unreachable, the player's Solo homestead remains fully playable. This is V1 trust at the level of a life: identity boundaries, grounded generation, persona policy, and crisis-aware safety are not a compliance layer bolted on — they are the core mechanic.

How the promise stays honest#

Two conventions keep V6's prose from drifting ahead of its tree, both detailed in ./glossary-and-conventions.md. First, the two-substrate discipline: anything in the metaverse half is V3's already-paid-for design, renamed (Egbe-World, Egbe-Gateway, Egbe-PxStream, Egbe-WebFB); anything in the agent half is the new code this page inventories. Second, the cross-reference convention: a bare §N/§N.M resolves to a numbered task in V6_TODOS.md, while deps§N → V6_DEPENDENCIES.md, features§"anchor" → V6_features.md, and v3features§"anchor" → the V3 architecture V6 reuses. The precise claim a reader can make today: V6's systems — 18 UE modules over 114 source files, 18 libs/v6/ packages with Rust co-implementations of the hot paths, seven Rust service crates, 14 typed contracts, and the in-tree UE automation harness — are real and code-grounded; the 10 GameFeatureData.uasset binaries make its districts and modes genuinely hot-activatable; and the content that would dress Orun (meshes, MetaHumans, VO, cinematics) plus the live operations (LLM inference, EOS, the Pixel Streaming GPU fleet) are production- and provider-gated, marked as such rather than implied.

Related#

• ../V6_features.md — the V6 feature map this page orients, with the full Orun, Ori, Moirai, stewardship, Vac, Aye-bridge, Commons, and governance catalogue.
• ./glossary-and-conventions.md — the subsystem glossary, the platform-substrate and cross-domain-support maps, and the cross-reference and two-substrate conventions behind every claim here.
• ./world-of-orun.md — the world model: the six districts, the shard continuum (Solo / Co-op / Commons), persistence, time and seasons, and the cross-platform client tiers.
• ../architecture/product-promise.md — the architecture companion: the two-substrate split against the compiler, the mind/body/memory authority topology, the Rust service plane, and the build/target matrix.
• Hub: ../V6_ARCHITECTURE.md; backlog ../V6_TODOS.md; dependency registry ../V6_DEPENDENCIES.md.