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.
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.uassetand 6.umapdistrict 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, and the runtime topology these surfaces sit on is ../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.
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.
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→BuildStructuredIntentreturning anFV6StructuredIntent), 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.
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, with the architecture in
../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 — the V6 feature map this page orients.
- ./overview-and-design-posture.md — the design posture (steward-not-owner, two-substrate reuse, fail-loud) the promise implies.
- ./meta-hub-and-commons.md — the Aye Bridge meta-hub and the shared Commons in full.
- ../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 — the architecture companion: how each commitment maps to a code anchor or an honest status.
- ../architecture/gateway-pixel-streaming-and-web-fallback.md — the gateway, Pixel Streaming relay fleet, and Tier-2 fallback architecture.