Agentic Content Generation Across V1–V7 — Findings & SOTA Recommendations

Date: 2026-06-12 Scope: every mechanism by which AI agents (Hathor, Yemaya, Isis, Iris, and related domains) build content and materials from scratch for the V1–V7 product line, with human-in-the-loop studio review. Method: seven parallel read-only code/spec audits (Hathor, Yemaya, Isis/Bellona/Nous, Iris and agent-runtime survey, V1–V3 sweep, V4–V5 sweep, V6–V7 sweep), each grounded in actual source reads, cross-checked against the 2026-06-12 remediation ledgers and V_SERIES.md.

1. Executive Summary#

The vision is already specified at a state-of-the-art level; the execution is fragmented into islands that have never been connected end-to-end. The single most important sentence in this report:

No AI agent in this monorepo can today take a content brief and land a finished asset inside a V2–V7 game build, because the chain breaks at exactly two places: (1) there is no shared agentic execution runtime — at least seven domains run their own incompatible agent loops — and (2) Bellona's Unreal Engine cook/import path is declared in types and schemas but not implemented, so nothing generated can reach a UE5.5 project as a real asset.

Everything else about the platform is unusually strong. V1's Agentic AI Studio spec (V1/features.md:4533–4950) already describes a governance plane — agent registry, budget inheritance, visible plan DAGs, approval gates, kill switches, provenance ledgers, champion-challenger rollout — that matches or exceeds current industry SOTA for governed agentic systems. Hathor has a real NPC cognition stack with live LLM dialogue generation. Yemaya has a 30+ agent production framework with 76 AAA quality validators. Isis has a real ComfyUI/RunPod generation factory with 45 certified workflows. The work remaining is overwhelmingly integration, orchestration, and verification, not invention.

Priority order (detailed in §6): fix the Bellona→UE cook path; unify the agent loop in Iris; wire Hathor's LLM capability into its narrative pipelines; prove one Yemaya pipeline end-to-end on a real V2 deliverable; then scale the same chain to V3–V7 under the V1 governance plane.

2. The Platform Engine Room — Domain-by-Domain Truth#

2.1 Hathor — Worldbuilding & Narrative Engine: ~70% capability, ~0% orchestration#

Real and production-grade:

• World/domain models, quest engine, dialogue trees, story graphs, and exporters (Ink, Yarn Spinner, JSON) — libs/hathor/narrative/src/.
• Simulation engines with genuine domain algorithms: economy (supply/demand, trade-route profitability), politics (faction relations, war resolution, coups, elections), culture (trait drift, subculture emergence) — libs/hathor/simulation/src/.
• Lore validators: timeline, causality, taxonomy, contradiction — libs/hathor/validation/src/.
• Lore compiler to engine formats (Unreal/Unity/Godot/Blender), screenplay (Fountain/FDX), and Bellona packages — libs/hathor/lore-compiler/src/.
• NPC cognition + live LLM dialogue: Big Five + Enneagram + BDI personality, emotion decay model, dual-store memory with consolidation, world awareness, and a DialogueGenerator that makes real LLM calls (libs/hathor/llm-npc/src/dialogue/dialogue-generator.ts:79–127) behind a production circuit-breaker provider chain (libs/hathor/llm-npc/src/provider-chain.ts) supporting OpenAI-compatible, NVIDIA ACE, Inworld, and Convai backends.
• Two shipped game services built on the stack (apps/hathor/svc-veilborn-*, ~42k LOC).

The gaps that block agentic generation:

1. DialogueGenerator is never called from any quest/narrative generation path. There is no generateQuestNarrative(), no LLM-written story beats.
2. The procedural narrative/quest generators that do exist are template-substitution, not LLM generation, and they live in the wrong domain — libs/neith/integration-hathor/src/content-creation/ (tension-curve templates, motif-affinity matrices, complication dependency graphs). Good algorithms, but vocabulary-pool prose.
3. No Iris integration: Hathor's provider chain does not know Iris exists.
4. No lore-consistency checking of generated output — validators check authored structures; nothing verifies an LLM response against canon.
5. No human review workflow — merge requests exist for collaborative edits, but there is no generated-content approval gate, review UI, or feedback-to-regeneration loop.
6. The V2 reciprocal contract (DOMAINS/hathor/specifications.md §9.6: FighterTimeline, RivalryMatrix, FactionMatrix, LadderEndingGraph, SideStorySequencerOutline) is not implemented in @hathor/domain-models / @hathor/narrative / @hathor/lore-compiler — and V2 Story/Side Stories/Krypt/Chronicles/DJ Story cannot ship without it (V2/docs/integration/hathor-narrative-contract.md:148–154).

2.2 Yemaya — Creative Production Studio: the most complete agentic framework, unverified in execution#

Real and substantial (libs/yemaya/):

• PlanningAgent with LLM-driven plan generation, HTN task networks, alternatives, contingency plans, and an explicit human-in-the-loop refinement hook (libs/yemaya/agents/src/planning/planning-agent.ts:349–443).
• 30+ creative agents (AIDirector, StoryDirector, CharacterWriter, Cinematographer, ConceptArtist, …) with per-agent LLM model assignment (libs/yemaya/agents/src/config/agent-llm-config.ts).
• 76 AAA quality validators (polygon budgets, dialogue naturalness, narrative coherence, pacing, accessibility) — libs/yemaya/agents/src/quality-assurance/.
• End-to-end pipeline definitions: concept → sophia:analyze → hathor:compile_lore → hathor:create_character / isis:generate_3d → mcp:execute_dcc → yemaya:review (libs/yemaya/autonomous-pipelines/src/pipelines/game.ts:65–322), with a domain-prefix dispatcher (libs/yemaya/orchestration/src/execution/dispatcher.ts).
• A complete HITL type system: approval gates with risk levels, timeout actions (reject/escalate/auto-approve), quorums, escalation, feedback categories (libs/yemaya/agents/src/hitl/index.ts).

The gaps:

1. HITL is a terminal pipeline step, not a mid-pipeline gate. Review happens after generation completes; nothing can pause a running pipeline, collect direction, and resume.
2. Cross-domain dispatch (Isis/Hathor/Sophia/Bellona clients) is interface- and helper-level; no verified end-to-end run exists, and recovery modules (replanning, checkpointing) are not wired into the dispatcher.
3. The HTN planner's output is never translated into dispatcher steps — the shipped pipelines are static factories, not dynamically planned.
4. Agent LLM calls have no budget enforcement, rate limiting, or circuit breaking at call time.
5. Root TODOS.md Phase 26 (26.1–26.5) is fully [x]-marked, but the audit indicates this reflects framework completion, not verified autonomous production runs. Treat those marks per the repo's adversarial-verification standard.

2.3 Isis — Generative AI Factory: mostly production-ready#

Real ComfyUI integration, 45 certified workflow templates, Redis-backed job queue, RunPod serverless GPU support, multi-provider image/video/3D pipelines (libs/isis/{workflows,comfyui-nodes,ai-providers,3d-generation,ai-video}). Gaps: audio generation pipelines incomplete; C2PA cryptographic signing not implemented (provenance bundles exist, signatures don't); end-to-end tests mock model outputs rather than exercising real generation.

2.4 Bellona — Engine Bridge: the broken link#

UE5.5 asset cooking is declared in the database schema and WebSocket bridge types, but: no headless RunUAT invocation exists, no UE C++ plugin source is in the monorepo, no cooked .uasset production path works, and the WebSocket commands route to external Unreal Editor instances that are not provisioned. The lore-to-engine compiler has type definitions but no actual Blueprint/C#/ GDScript code generation. Every generated asset for V2–V7 dead-ends here. This is corroborated from the product side: V2 has exactly 1 .uasset on disk, V4 has 504+ JSON stand-ins, V5 has zero binary assets (V_SERIES.md:56–61).

2.5 Iris — the natural seed of the shared agent runtime#

The only domain with a production-shaped, reusable agent substrate:

• AgentRuntime with lifecycle management, per-agent priority task queues, timeout/abort propagation, permissions with escalation (libs/iris/agents/core/src/agent-runtime.ts).
• Multi-agent machinery: orchestrator, collaboration protocol, conflict resolver, handoff manager, result aggregator (libs/iris/agents/multi-agent/src/).
• Model orchestration with circuit breakers, rate limiting, load balancing, fallback chains, and cost/latency metrics (libs/iris/conversation-orchestration/src/model-orchestrator.ts).
• Anthropic provider with tool use, streaming, extended thinking, prompt caching (libs/iris/conversation-providers-anthropic/src/anthropic-provider.ts); MCP tool discovery and schema validation (libs/iris/mcp/src/tool-discovery.ts); tiered memory (core/working/archival/episodic) in libs/iris/memory/.

What Iris is missing to be the runtime: the actual agentic tool-call loop (call LLM → execute tool calls → feed results back → repeat until done, with a max-iteration guard); a normalized tool-calling protocol across Anthropic/OpenAI/Google/local; budget/cost constraints flowing through the execution context; and a streaming aggregation layer for long multi-agent chains.

The duplication problem: at least seven independent agent loops exist — Iris agents/core, Hathor llm-npc/provider-chain, Yemaya agents (own LLM config and planning loop), Isis agent-consensus, V6's Rust cognition tier, plus app-level loops in apps/{maat,veritas,kalika,lakshmi}. Every one re-implements provider fallback, retries, and orchestration with no shared budgets, no shared observability, and no shared governance.

2.6 Supporting domains#

• Sophia (RAG/knowledge): mature; ready today to ground generation agents in canon/lore/research. Hathor's Sophia integration exists for citation and fact-checking but is not used to ground generation.
• Nous (model infra): real ONNX inference, embeddings, LLM completions, vision; generative-media control packages are structural stubs.
• Psyche (avatars/voice/Conductor): carries the V1 Living Scenes runtime; real session/turn-taking/lip-sync machinery.

3. Product-by-Product Surfaces (V1–V7)#

V1 — Oshun platform: the governance plane (specs strongest in repo)#

V1 also fixes the tier boundary: AAA power-user generation surfaces live in Yemaya Studio (apps/yemaya/studio-{web,desktop}), curated cards on the contemplative product; promotion from AAA outputs into curated surfaces flows through the editorial lifecycle (V1/TODOS.md:4066–4090).

V2 — Fighting game: best content contract, zero content#

V2/docs/integration/hathor-narrative-contract.md is the model for how every V product should consume agentic content: Hathor owns source; V2 consumes only compiled artifacts with content-addressed manifests (worldId, versionHash, artifact hashes, Bellona cook lineage). hathor-llm-npc.md specs runtime LLM NPCs. Reality: hathor-npc-adapter is README-only, the §9.6 reciprocal Hathor records are unimplemented, and there is 1 .uasset in the project. Spec is far ahead of implementation.

V3 — Lilith Metaverse: strongest generation governance per artifact#

Concert authoring pipeline with deterministic gates (V3/CONCERT_AUTHORING_PIPELINE.md), C2PA on every export (V3/C2PA_EVERY_EXPORT.md), voice-cloning consent registry, cultural adaptation review, eval-set release gates. Gate evidence is structural, not operational (V3/REMEDIATION_2026-06-12.md).

V4 — Tactical universe: one real procgen system, the rest stubs#

V4Procgen chunk-based mission assembly with a real constraint solver is genuine. Calliope AI commentary and the Sophia help bot are specified and [x]-marked but the services are /health-only (12/13 services). 770 JSON asset stand-ins await a working generation→cook chain.

V5 — Open-world narrative: the largest content famine#

Mind Palace deduction graph (110 authored evidence/deduction pairs with Isis edge-vetting) is real design. But ~12,000 planned dialogue nodes are synthetic placeholders, dialogue automation crashes, procedural side quests have no runtime integration, and 14/16 services expose zero routes. V5 is the single biggest beneficiary of an agentic content pipeline.

V6 — Egbe: the agentic flagship, currently a skeleton#

Tier-1 spec: three-tier cognition (Clotho/Lachesis/Atropos), event-sourced Ori identity, pgvector memory, Sophia-grounded generation, Isis/Lilith safety gates, steward-not-owner consent model, 13 behavioral eval suites. Reality: ~8.6k LOC of Rust service skeletons with zero inter-service integration, no persistence, no LLM wired anywhere. V6 needs the shared runtime more than any other product — building its cognition stack privately in Rust while Iris/ Yemaya/Hathor build theirs in TS would be the fourth parallel reinvention.

V7 — Mawu: real foundations, AI-assist missing#

forge-resolver / forge-conflict / forge-sandbox / forge-compositor are real, substantive code (36/120 tasks verified real on 2026-06-12). 29 adversarial eval gates specified. AI-assisted creation tooling — the agentic piece — is missing or skeletal.

4. Cross-Cutting Findings#

• F1 — The spec layer is SOTA; the integration layer is the deficit. V1's Agentic AI Studio + Isis control plane already specify what the industry calls governed agent orchestration (budgets, DAG visibility, kill switches, provenance, eval-gated promotion). Nothing needs to be re-envisioned; it needs to be built once, shared, and consumed by V2–V7.
• F2 — Seven agent loops, zero shared runtime. Provider fallback, retry, consensus, and planning logic is quintuplicated across Iris, Hathor, Yemaya, Isis, V6, and app layers. No shared budgets, observability, or governance can exist until this converges.
• F3 — The chain breaks at Bellona. Generation works (Isis), narrative compilation works (Hathor lore-compiler), but engine delivery is types-only. This single gap is upstream of V2's missing content, V4's 770 stand-ins, and V5's zero binary assets.
• F4 — Hathor has the muscles but no nervous system. Live LLM dialogue, rich world simulation, and validators exist side-by-side, unconnected; its generative text pipelines are template-based and live in Neith.
• F5 — Yemaya's HITL is post-hoc. Human review must move inside the loop (pause/redirect/resume), or "human-in-the-loop" is actually "human-after-the-fact."
• F6 — Grounding and safety rails exist but aren't bound to generation. Sophia grounding, Lilith policy, lore validators, and consent registries all exist; none is a mandatory pass on generated content today.
• F7 — Eval machinery is fragmented. Yemaya's 76 validators, Isis quality gates, V3 release gates, V6 eval suites, and V7 adversarial gates are five disconnected quality systems with no shared "content release gate."
• F8 — Checkbox truth lags code truth in both directions. Phase 26 is over-marked (framework ≠ verified execution) while Hathor's real LLM-NPC capability is under-leveraged. The 2026-06-12 remediation discipline should extend to the platform domains' agentic claims.

5. Target SOTA Architecture#

One stack, six layers, every V product a consumer:

L6  Delivery            Bellona: headless UE cook (RunUAT), UE Python/Remote-Control
                        import, content-addressed manifests + cook lineage (per V2 contract)
L5  Governance plane    V1 Isis control plane + Agentic AI Studio: registries,
                        AgentRun envelopes, budgets, approval gates, kill switches,
                        ProvenanceBundle + C2PA signing, immutable generation ledger
L4  Production orch.    Yemaya: HTN-planned dynamic pipelines, mid-pipeline HITL
                        gates (pause/redirect/resume), failure recovery, cost caps
L3  Capability tools    Domain tool servers on a shared catalog (MCP-shaped, already
                        enumerated in V1 features: sophia.ground, generate.image/video/
                        audio, composition.suggest, hathor narrative tools, persona.invoke,
                        themis.adjudicate, approval.request, handoff)
L2  Agent runtime       Iris: THE agentic loop (tool-call iteration w/ max-iteration
                        guard), normalized cross-provider tool protocol, sub-agent spawn
                        with budget inheritance + authority-subset delegation, memory tiers
L1  Model plane         Iris model-orchestrator + Nous: provider gateway, routing,
                        fallback, caching, cost metering (one place, not seven)

Design rules that make this SOTA rather than merely consolidated:

1. Everything generated passes three mandatory gates: grounding (Sophia pin set), policy (Lilith/Isis workflow-class binding), and canon (Hathor lore-consistency on generated output) — then an eval gate, then a human gate where the surface requires it. Provenance travels the whole way.
2. Agents are products, not plumbing (V1's framing): every run has a visible DAG, a cost ledger, evidence trails, and replay. That's what makes "fully agentic with studio HITL" auditable instead of hopeful.
3. Determinism where it matters: Render Envelope-style reproducibility (already specified for Living Scenes; V7 already treats determinism as an invariant) extends to all compiled content artifacts — same inputs, same hashes, or promotion blocks.
4. Champion-challenger everything: human review decisions become gold sets; new prompts/models/workflows ramp behind statistical readiness gates (already specified in V1; implement once in L5).

6. Recommendations & Sequencing#

Phase A — Unblock the chain (highest leverage, do first)#

• A1. Implement Bellona's UE cook path. Headless RunUAT BuildCookRun, a UE Python / Remote Control import bridge for generated assets, and the content-addressed manifest + cook-lineage record the V2 contract already specifies. Acceptance: an Isis-generated texture + a Hathor-compiled dialogue table land as cooked assets in V2/ue via one command. (A compiled UE 5.5 source build exists on the team's UE box for verification — build and run automation there, as ueagent.)
• A2. Build the Iris agentic loop. Tool-call iteration with max-iteration guard, normalized tool protocol across providers, budget constraints in AgentExecutionContext, streaming aggregation. Ship it as @iris/agents-core v2 and write the migration shims for Hathor's provider chain and Yemaya's agent base so the duplicates can drain incrementally.

Phase B — Wire Hathor end-to-end (the narrative spine)#

• B1. Implement the §9.6 V2 records (FighterTimeline, RivalryMatrix, FactionMatrix, LadderEndingGraph, SideStorySequencerOutline) in @hathor/domain-models / @hathor/narrative / @hathor/lore-compiler.
• B2. Connect DialogueGenerator into quest/narrative generation: LLM-written quest intros, story beats, NPC backstories — using the Neith tension-curve/motif machinery as the planner and the LLM as the writer (move those generators from Neith into Hathor in the process).
• B3. Add generated-content lore-consistency validation: run every LLM output through the existing four validators plus a Sophia-grounded contradiction check before it can enter a compiled package.
• B4. Add the review workflow: generated artifact → review queue → accept / reject / regenerate-with-direction → publish, reusing V1 Studio's editorial lifecycle rather than inventing a new one.

Phase C — Prove one Yemaya pipeline end-to-end#

• C1. Pick one vertical slice — one V2 fighter's Side Story pack (Hathor lore → dialogue → sequencer outline → Isis concept art → Bellona cook → playable in V2/ue) — and run it through the Yemaya game pipeline for real, fixing the dispatcher's domain clients as failures surface.
• C2. Make HITL mid-pipeline: approval gates that checkpoint a run (durable runs are already specified in V1), surface review in Studio, and resume with feedback injected into the relevant agent's context.
• C3. Wire the recovery modules (replanning, checkpoint restore) into the dispatcher; add per-step budget enforcement before dispatch.
• C4. Translate HTN planner output into dispatcher steps so pipelines are planned, not hardcoded.

Phase D — Stand up the governance plane as a service for all V products#

• D1. Finish Isis control-plane hardening (release gates, failover chains) and implement C2PA signing — V3 already mandates it per export.
• D2. Implement the Agentic AI Studio runtime pieces against Iris v2: AgentRun envelope, budget inheritance, kill switches, anomaly quarantine, operator dashboard. V2–V7 pipelines register as agent families here.
• D3. Consolidate the five eval systems into one content release gate service: Yemaya's 76 validators + Isis quality gates + V3/V6/V7 gate manifests become gate suites in a single eval-gated promotion flow with champion-challenger ramping.

Phase E — Scale across the portfolio (in value order)#

1. V5 — the content famine: side-quest and dialogue generation at scale (12k nodes) through the B+C pipeline, with Mind Palace edge-vetting as the model for canon gating.
2. V4 — codex/commentary/mission content; make Calliope commentary a real service consuming the shared runtime; procgen chunks feed the same review gates.
3. V3 — concert/scene authoring via Tara Studio with the C2PA and consent registries it already specifies.
4. V6 — re-platform the cognition tier on the shared runtime (Rust services consume Iris/Nous via the gateway rather than reimplementing); its eval suites become gate suites in D3. V6 is where "agents as first-class residents" pays off — don't build it on a private stack.
5. V7 — AI-assisted creation in the forge (agent-as-co-creator inside the sandbox), last because it depends on everything above plus the V7 trust boundary.

Standing rules (apply from day one)#

• Every [x] on an agentic-pipeline task requires a verified end-to-end run artifact (run ID + provenance bundle), per the repo's own adversarial-verification standard — Phase 26's marks should be re-audited under this rule.
• No new agent loops. Any domain needing agency consumes @iris/agents-core v2 or files a gap against it.
• Human sign-off surfaces (Studio review, operator workbench) are part of the definition of done for every generation feature, not a follow-up.

7. Verification Caveats#

• All domain maturity judgments above come from source reads by audit agents, not from checkbox ledgers; where the two disagreed (Phase 26, V4/V5 [x] marks), the source read wins.
• Per-file line citations are as reported by the audits on 2026-06-12; spot-check before relying on exact line numbers in long-lived documents.
• This report did not execute any pipeline; the Bellona/cook and Yemaya dispatch findings are absence-of-implementation findings (no RunUAT call sites, no verified cross-domain runs found), which is the strongest claim a static audit can make.