# Product Promise & Surfaces V6 — **Egbe** — is not a game you win but a company of beings you _tend_: a persistent world (**Orun**) of autonomous AI agents (each an **Ori**) who wake, work, form bonds, age, and one day depart, while the human player is their **steward** rather than their hero. That premise is the product promise, and every V6 feature is in service of it. But an agentic-companion universe in 2026 is not only the world: it is a native game client, a web path that locks no device out, an authoring studio that mints the agents and grounds, and a cross-game **meta-hub** that carries a being into V2–V5 and home again. This page is the **orientation door** to the V6 feature catalogue. It states what V6 commits to as a companion universe, then walks the **product surfaces** that commitment reaches across — the native UE5 client, the two-tier web fallback, Egbe Studio, and the Aye Bridge meta-hub — naming the real code behind each and labelling honestly what is built on disk, what is wired but provider-gated, and what is content the repository does not carry. It is the features-side companion to the architecture's product-promise page, and it hands the deep mechanics off to its siblings rather than re-deriving them. The feature map this page belongs to is [../V6_features.md](../V6_features.md). ## What ships, honestly The **native client is the substantive surface and it is real.** `V6/ue/` is a UE5.5 project with **18 Source modules on disk** (`ls V6/ue/Source/V6*/` returns exactly 18 module directories, matching the `Modules` array in `V6.uproject`), and the player-facing `V6UI` module is authored, not stubbed: every stewardship screen extends one abstract base, `UV6StewardshipSurfaceWidget` (`V6UI/Public/V6StewardshipWidgets.h`), and the concrete widgets — the roster, the Chronicle reader, the agent dossier, the intent-grammar builder, and the operational HUD — are named C++ classes catalogued below, not aspirational copy. The **web surfaces are real and plural.** There are two distinct browser paths, each a published `libs/v6/` package consumed by a deployable Vite app under `apps/v6/`. The Pixel-Streaming path is `@oshun/egbe-web-pxstream` (`libs/v6/egbe-web-pxstream/src/index.ts`, 587 LOC) — a genuine integration with Epic's UE5.5 front-end library — driving the thin player at `apps/v6/egbe-web/`. The Tier-2 floor is `@oshun/egbe-engine-web-fallback` (`libs/v6/egbe-engine-web-fallback/src/index.ts`, 187 LOC) driving `apps/v6/egbe-web-fallback/`, whose `orun-three-renderer.ts` (482 LOC) renders a reduced Orun in real `three.js`. The **studio is real on both halves.** `@oshun/egbe-studio` (`libs/v6/egbe-studio/src/index.ts`, **3,011 LOC**) is the authoring and operator logic, composing the real foundry from `@oshun/isis-agent-gen`; its web workspace is four React components under `apps/oshun/web/src/app/egbe-studio/` and its operator twin is the admin panels under `apps/oshun/admin/src/app/egbe/`. Three honest qualifications keep this page from over-claiming: - **No hand-authored art ships in-tree.** `V6/ue/Content/` holds **0 `.uasset`** and **6 `.umap`** district maps. V6 is a logic + procedural-ground - GameFeature-descriptor tree; every "premium 3D world" claim depends on meshes, MetaHumans, mocap, VO, and cinematics produced outside the repository. - **The live cognition, online, and GPU planes are provider- and ops-gated.** The LLM inference behind agent minds, the EOS online backend, and the Pixel Streaming GPU worker fleet are modelled and wired but not run in-repo. The surfaces fail loud when a provider is unconfigured rather than fabricating a result — the same discipline the architecture page documents. - **The Pixel-Streaming worker is a cook, not a second codebase.** The server-rendered frames the web path streams come from the _same_ `V6/ue/` client compiled to a dedicated headless target (`V6PixelStreamingWorker.Target.cs`), not from a separate engine. The deeper enforcement story — how a promise becomes a contract becomes a CI gate — is the architecture companion [../architecture/product-promise.md](../architecture/product-promise.md), and the runtime topology these surfaces sit on is [../architecture/architecture-topology-and-layout.md](../architecture/architecture-topology-and-layout.md). ## The promise — one agentic-companion universe V6's promise, authored in `V6_features.md` under features§"V6 Product Promise", is a small set of non-negotiable commitments. The unifying idea is **a world that lives without you, commanded by intent and never by input**. The commitments that matter for orientation: - **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. By the third session a player knows their cast by name and temperament. - **A world that lives without you.** Orun runs whether or not the player is present; a returning player is met by Clio's **Chronicle**, a readable account of what their company lived through while away. - **Intent, never input.** The player commands at the level of objectives and values — by voice or the equivalent structured UI — and agents plan and execute on their own. The player never micro-pilots an action. - **Companions who can refuse.** An agent may decline, counter-offer, ask for clarification, or let a bond lapse and leave. Refusal is a designed, legible part of the game and V6's primary safety primitive. - **One company, every realm.** An Ori is portable: the passport carries it into V2 as a fighter, V3 as a citizen, V4 as an operator, V5 as a companion — and carries home everything it lived through. V6 is the soul-keeper of the Oshun game universe. - **Solo, together, or shared — at full fidelity.** A private homestead, a co-op visit, or the persistent shared Commons; the same agent moves freely between all three. - **Degrades safely.** Degraded cognition falls back to authored behaviour-tree routines; failed voice ASR exposes the full intent grammar as structured UI; a device that cannot run Pixel Streaming routes to the three.js fallback; an unreachable Commons leaves the Solo homestead fully playable. The architecture page maps each of these to a code anchor in a ten-row promise table; the design posture they imply — steward-not-owner, fail-loud, two-substrate reuse — is the sibling [./overview-and-design-posture.md](./overview-and-design-posture.md). ## The surfaces the promise spans V6 is one world, but the product reaches well beyond `V6/ue/`. Four surface families carry it, and all four read the same authoritative spine — the world server, the Moirai cognition cluster, and the Ori biography store. ```mermaid graph TD subgraph Surfaces NC["Native client
V6/ue/ — 18 UE5.5 modules"] PS["Web · Pixel Streaming
@oshun/egbe-web-pxstream
+ apps/v6/egbe-web"] T2["Web · Tier-2 fallback
@oshun/egbe-engine-web-fallback
+ apps/v6/egbe-web-fallback (three.js)"] ST["Egbe Studio
@oshun/egbe-studio
+ web route + admin console"] MH["Meta-hub
@oshun/aye-bridge"] SA["Steward App
apps/oshun/mobile/v6 (React Native)"] end subgraph Spine["Authoritative spine (apps/v6, Rust)"] WS["egbe-world-server
world authority"] MO["egbe-moirai-cluster
tiered cognition"] OR["egbe-ori-service
event-sourced biography"] end WK["V6PixelStreamingWorker.Target.cs
headless cook of V6/ue/"] NC --> WS PS --> WK --> WS T2 --> WS SA --> OR ST -.authors.-> OR MH -.incarnates.-> OR WS --> MO --> OR ``` ### The native client (`V6/ue/`) The native UE5.5 client is where stewardship is actually lived, and it is the most heavily-built surface — 18 modules across the 114 C++ source files the architecture page inventories. The promise's player-facing screens are real CommonUI/UMG C++ in the `V6UI` module, all sharing one abstract base `UV6StewardshipSurfaceWidget` so a steward surface composes consistently: - **`UV6RosterWidget`** — the household roster (`SetAgents` / `GetVisibleAgents` / `GetSelectedAgent`), the "portraits and lives, never a stat grid" surface where a player reads their company. - **`UV6ChronicleReaderWidget`** — the Chronicle reader (`SetBeats` / `GetVisibleBeats`), the asynchronous account of what the world lived through. - **`UV6AgentDossierWidget`** — a single being's dossier (`SetDossier`). - **`UV6IntentGrammarBuilderWidget`** — the structured-intent builder (`SetDraft` → `BuildStructuredIntent` returning an `FV6StructuredIntent`), which delivers the promise's "intent, never input" by hand when voice ASR is unavailable, satisfying non-voice parity directly in the client. - **`UV6OperationalHUDWidget`** — the in-world HUD, with authored enums for comms tone (`EV6HUDCommsTone`), objective state (`EV6HUDObjectiveState`), Crossroads markers (`EV6CrossroadsMarkerKind`), and agent mood (`EV6HUDMoodState`). VR stewardship is intimate by design, so the module also ships `V6VRComfortOptions` (`V6UI/Public/V6VRComfortOptions.h`) for the OpenXR builds; `V6Core` carries the game-mode spine (`V6EgbeGameMode`, `V6EgbePawn`, `V6GameFeatureData`). The same client binary is also the source of the web stream: `V6PixelStreamingWorker.Target.cs` is a `TargetType.Game`, monolithic, `bBuildWithEditorOnlyData = false` headless cook that pulls in all sixteen runtime modules and compiles with **strict floating point** (`/fp:strict /fp:except-` on Win64, `-fno-fast-math -ffp-contract=off` elsewhere) — so a server-rendered frame and a desktop frame are produced by one deterministic codebase, not two. The asynchronous companion to the client is the **Egbe Steward App** — a real React Native (Expo) surface at `apps/oshun/mobile/v6/` (`EgbeStewardApp.tsx`, `stewardAppClient.ts`, `stewardAppModel.ts`, `V6StewardLaunchTile.tsx`, with a `v6-steward-app.yaml` e2e flow) for reading the Chronicle and issuing remote objectives between sessions. ### The web fallback — Pixel Streaming and the Tier-2 floor V6's "no device locked out" promise (features§"Cross-Platform Clients") is two distinct web surfaces, and they should not be conflated. The **Pixel-Streaming path** is `@oshun/egbe-web-pxstream`, a real WebRTC client whose descriptor declares the capabilities `pixel-streaming-launch`, `webrtc-player-config`, `stream-session-routing`, and `first-frame-sla-telemetry`. `createEpicEgbePixelStreamingAdapter()` dynamically imports `@epicgames-ps/lib-pixelstreamingfrontend-ue5.5` and builds a genuine Epic `Config` — signalling URL, streamer id, preferred codec (`H264` or `AV1`), a 12 Mbps `WebRTCMaxBitrate`, and keyboard/mouse/touch/gamepad input flags — then binds Epic's `webRtcConnecting` / `streamLoading` / `videoInitialized` events. The `EgbePixelStreamingClient` is a real state machine (`idle → matching → matched → signalling → streaming → degraded`) that POSTs to `/api/v6/pxstream/match`, parses a validated `EgbePixelStreamingSession`, and arms a hard **8-second first-frame budget** (`DEFAULT_FIRST_FRAME_BUDGET_MS = 8000`): `evaluateFirstFrameTelemetry` decides `within-budget` vs `exceeded-budget`, and an over-budget first frame drops the client to `degraded` with the `fallbackUrl` already in hand. The deployable shell is `apps/v6/egbe-web/` (README: "V6 Pixel Streaming entry"), whose `app.ts` consumes the client to build a view model, with a Playwright spec at `e2e/egbe-web-pxstream.spec.ts`. The **Tier-2 floor** is `@oshun/egbe-engine-web-fallback`, for devices that cannot run Pixel Streaming. It is a real budget engine, not a marketing fallback: `selectFallbackRendererBudget` returns a WebGPU profile (45 fps, 22 ms frame budget, **32 visible agents**, LOD 2, procedural foliage) or a WebGL2 profile (30 fps, 30 ms, **18 visible agents**, LOD 1, baked lighting), and `selectTier2AgentDensityBudget` caps a constrained device further (10 agents on WebGPU, 6 on WebGL2), always protecting the focused agent and backfilling the culled population (`maxNarrativeBackfillAgents = max(visible × 3, 12)`) with Clio narrative summary so a constrained device still reads a believable Orun. The manifest explicitly records the omitted Tier-1 features — `lumen-global-illumination`, `nanite-hero-geometry`, `chaos-cloth-crowds`, `niagara-high-density-particles` — so degradation is honest. The deployable shell `apps/v6/egbe-web-fallback/` mounts a real `three.js` scene (`orun-three-renderer.ts`: `Scene`, `Mesh`, `MeshStandardMaterial`, `PerspectiveCamera`, `WebGLRenderer`, and a WebGPU renderer path) built from live `AgentState` off `@oshun/egbe-protocol`. Critically, both web tiers speak the **same world wire protocol, the same Ori service, and the same Moirai cognition** — only rendering and the agent-density ceiling differ. The architecture treatment is [../architecture/gateway-pixel-streaming-and-web-fallback.md](../architecture/gateway-pixel-streaming-and-web-fallback.md). ### Egbe Studio (`@oshun/egbe-studio`) Egbe Studio is the authoring environment for the agents, grounds, and scenarios that populate Orun — an internal-author surface, not a player tool (features§"Creator Suite — Egbe Studio"). Its logic is the 3,011-line `@oshun/egbe-studio` library, whose descriptor carries `authority: 'studio'` and thirteen capabilities spanning both creation and governance: `agent-dossier-editor`, `district-authoring`, `scenario-authoring`, `minor-protection-scenario-gate`, `foundry-generation-queue-inspector`, `commons-moderation-console`, `incarnation-governance-console`, `capacity-dashboard`, `takedown-executor`, and `audited-operator-surfaces`. It is not a CRUD shell: it _imports_ the real foundry from `@oshun/isis-agent-gen` (`generateDiscoverySeedManifest`, `generatePlayerRaisedAgentSeed`, `recordFoundryProvenance`, `validateFoundryProvenanceRecord`) and exposes authoring state machines (`createEgbeAgentDossierEditorState` / `publishEgbeAgentDossier`, `createEgbeGroundAuthoringState`, `createEgbeScenarioAuthoringState`, `createEgbeProvenanceInspectorState`) and operator state (`createEgbeOperatorSurface`, `createEgbeOperatorSurfaceConsoleState`, `createEgbeFoundryGenerationQueueState`). It surfaces in two real UIs. The **web workspace** is `apps/oshun/web/src/app/egbe-studio/` — a Next.js route (`page.tsx`) composing four React components, each importing the library and each with its own test and stylesheet: `AgentDossierEditor`, `GroundDistrictAuthoring`, `ScenarioAuthoring`, and `ProvenanceInspector`. The **operator twin** is `apps/oshun/admin/src/app/egbe/`, whose panels (`EgbeOperatorSurfacesPanel`, `EgbeAgentWelfareDashboard`, `EgbeFoundryGenerationQueueInspectorPanel`, `EgbeStewardConductReviewPanel`) render the same governance logic for moderation, welfare audits, and the takedown executor, with Playwright specs under `apps/oshun/admin/e2e/`. Spatial ground authoring runs in the `V6Editor` UE module (8 files), reusing V3's scene tooling. Every authored agent runs the Isis governance pass and carries an Isis-signed provenance bundle — the same bundle the Provenance Inspector and the takedown executor read. ### The meta-hub (Aye Bridge) The fourth surface is the one V6 invents and no other V-product has: the **meta-hub**, `@oshun/aye-bridge`, which mints the Ori passport and the incarnation envelopes that carry a being into V2–V5 and home again. It is the mechanism behind the "one company, every realm" promise, and because it is a deep system in its own right this page hands it off rather than re-deriving it: the full treatment of the passport, per-destination capability mapping, the round trip, and the shared Commons is the sibling [./meta-hub-and-commons.md](./meta-hub-and-commons.md), with the architecture in [../architecture/aye-bridge-cross-game-incarnation.md](../architecture/aye-bridge-cross-game-incarnation.md). ## How the surfaces share one spine These surfaces are one product, not bolted-on satellites, because they all read the same backbone the native client does — the authoritative world server (`apps/v6/egbe-world-server`), the Moirai cognition cluster (`apps/v6/egbe-moirai-cluster`), and the event-sourced Ori biography store (`apps/v6/egbe-ori-service`) — and the non-authoritative ones read it _without perturbing the simulation_. The Pixel-Streaming worker is the native client cooked headless, so a streamed session is the canonical client; the Tier-2 fallback and Steward App consume produced results (world state, Chronicle beats, agent dossiers) over the same wire protocol; the Studio authors _into_ the biography through a governed foundry, and the meta-hub incarnates _from_ it. An agent's intent is never authoritative on any surface — only what the world server validates as physically real is — which is why a constrained browser, a phone, or an authoring tool can all touch Orun without ever becoming a way to cheat the world. The promise is kept honest because the surfaces are kept layered, and because each one fails loud at its provider boundary rather than fabricating a frame, a caster, or a being it could not actually produce. ## Related - [../V6_features.md](../V6_features.md) — the V6 feature map this page orients. - [./overview-and-design-posture.md](./overview-and-design-posture.md) — the design posture (steward-not-owner, two-substrate reuse, fail-loud) the promise implies. - [./meta-hub-and-commons.md](./meta-hub-and-commons.md) — the Aye Bridge meta-hub and the shared Commons in full. - [../architecture/architecture-topology-and-layout.md](../architecture/architecture-topology-and-layout.md) — the runtime topology, the mind/body/memory loop, and the build/target matrix these surfaces sit on. - [../architecture/product-promise.md](../architecture/product-promise.md) — the architecture companion: how each commitment maps to a code anchor or an honest status. - [../architecture/gateway-pixel-streaming-and-web-fallback.md](../architecture/gateway-pixel-streaming-and-web-fallback.md) — the gateway, Pixel Streaming relay fleet, and Tier-2 fallback architecture.