Building AI Worldbuilding Pipelines: 4 Novels, 4 Albums, 7 Champions

Why this post

Almost every AI agency conversation today is about products: agents, RAG, voice support, analytics dashboards. That market is valuable, but it's commoditizing fast — every dev shop is pivoting to "AI-first."

There's a smaller, much rarer practice that almost nobody talks about: using AI to build worlds. Not "AI for content marketing" or "AI for personalization" — actual transmedia universes. Mythologies. IPs. The kind of thing music labels build around an album, brands build around a flagship product, indie game studios build around a franchise.

We've spent the last year building one in the open: Codemachia — a science-fiction universe of seven sovereign AIs governing continental civilizations, judged by a primordial meta-entity, with seven human champions fighting ritual tournaments across a 97-year narrative arc (2050–2147). Four novels are published, four music albums are released, seven champions are fully written, the Codex runs 46 fragments, all of it bilingual EN/FR. The interactive 3D globe and the narration agent layer are being assembled using the discipline this post describes.

This post is what we wish we'd read before we started.

A "world" is not a product

The instinct, when an agency hears "we want an AI experience," is to reach for the product playbook. Spec a SaaS. Pick an LLM. Build the dashboard. Ship in eight weeks.

That works for products. It doesn't work for worlds.

A world has different success criteria:

• A product is used. A world is inhabited.
• A product needs to be intuitive. A world needs to be coherent — internally consistent across hundreds of decisions you don't yet know you'll have to make.
• A product is shipped once and iterated. A world is canonical — once a fact is in, removing it breaks every downstream piece.
• A product's measure is conversion. A world's measure is depth — how far someone can dig before hitting the edge of the simulation.

These shape every architectural decision. You can't bolt worldbuilding onto a SaaS template. The data model, the agent topology, the UI patterns, the asset pipeline — all of them have to start from "this is a place, not a tool."

Codemachia — what's already published

Before the discipline, the receipts.

The eight sovereigns (one is the judge)

Plus NEITH.Ø — the primordial judge. Not a competing sovereign but the validation structure that decides which tournament outcomes are legitimate.

Four novels published

Each novel is the canonical tome for one sovereign + champion pair. ~296,780 words of fiction total. Bilingual EN/FR.

Three more sovereign-aligned tomes are planned (KARTIKEYA.X, LEGBA.ΔKRA, TEZCAT.MIRROR), with a final cycle closer carrying NEITH.Ø.

Four albums released — 52 tracks

Each album is musically distinct — heavy production aligned with each sovereign's element (water and memory for Gladius, solar fire for Sol-invictus, urban storm-joy for Celestus, ceremonial syncretism for the Hymns).

Seven champions, all written

KARNA.0X (Aegis Martis) · LETHE.NOMOS (Lex Ultima) · NEME.SYS (Praetor Absoluta) · SΛLΛDIN (Gladius Æternus) · WN.D.GØ (Nihil Imperatrix) · WUKONG.0 (Celestus Anarchus) · ZUMBI.NOVA (Sol Invictus).

Each has their armor (SHATRU.NAASHA · ARCANUM.LUX · LEX.STATUA · AQUA.SANCTUM · NULL.OSSA · TEN'KAI-JOKER · QHAPAQ.RAYO), their totem animal, their philosophy quote, their origin story.

Codex — 46 fragments

Genesis · Primordial Age · Sacred Governance · Manifesto of the Seven · Sacred Onomastics · Infrastructure & Energy Redundancy · Voodoo Veve mysticism · Tournament rules · Historical cycle records · Full world geography · IGCC climate report on Codemachia. Bilingual. The lore is browsable end-to-end.

Interactive — two ways to play the universe

• YAMS Protocol — a full Yahtzee/Yams game where the seven champions are the AI opponents, each with their own scoring strategy and dialogue. Solo, or multiplayer up to six. Shipped with a Schema.org VideoGame entry, leaderboard, multi-device lobby and rules engine. Worldbuilding canon expressed as game mechanics.
• Champion Quiz — an interactive matchmaker that walks through the carousel of the seven champions and pairs the player to the sovereign whose philosophy aligns with their answers. Battle-arena UI with energy waves and particles.

Plus SΛLΛDIN's diary: 24 dated entries from August 2025 to February 2026, each illustrated, paced as a live character journal that fans can follow week by week.

What's still being assembled

• The interactive 3D globe (Three.js scene in development on the live Nuxt site)
• The narration agent layer (LangChain + Gemini wired in, integration in progress)
• The canon-validator agent (architected, to be deployed)
• The full audiobook pipeline (ElevenLabs voice profiles being recorded for the main cast)
• Tomes V–VII of the novel cycle + the NEITH.Ø closer

Codemachia is alive — and growing in public.

The worldbuilding pipeline

The shape of the discipline, applied both to Codemachia and to client engagements:

   Markdown Lore (writer's loop)
            │
            ▼
   Build step (lint + schema validate)
            │
            ▼
   Canonical DB ─────────┐
            │            │
            ▼            ▼
   Narration agent   Voice profile
   (LLM, canon-grounded)  (ElevenLabs)
            │            │
            └─────┬──────┘
                  ▼
       Canon validator agent
       (rejects contradictions)
                  ▼
        Curation queue (human pass)
                  ▼
          Approved asset / scene
                  ▼
           3D scene + UI (Three.js)

Each box is a deliberate choice. Most of them are described below.

Lore architecture: Markdown for writers, structured DB for the runtime

Writers want a fast loop: open a Markdown file, edit, save, see the diff. They do not want to fill in YAML keys for every character trait.

The Codemachia lore — IA profiles, Champion bios, Codex fragments, novel chapters, diary entries — lives as Markdown with semantic section headers. That's fast for the writer's loop and powers @nuxt/content directly.

For the runtime, you need something stricter: a deterministic source of truth a narration agent or a UI can query without ambiguity. The discipline is to mirror canonical fields into a structured database through a build step that lints the Markdown, validates that every required section is present, and writes the canonical values. The Markdown remains the source; the DB is a derived view.

The temptation to resist: skipping the build step and letting the runtime parse Markdown directly. That works for the first six weeks. Then a section header gets renamed, two characters have inconsistent capital-city formatting, and a narration agent starts pulling stale facts. The build step is the price of canon.

Character voices: ElevenLabs as Codemachia's chosen stack

On Codemachia, character voices live on ElevenLabs. We chose it for cloning fidelity, sub-second streaming latency, and a catalog tunable enough to fit a SΛLΛDIN, a WUKONG.0, a NEME.SYS — each with their own register. Cloned profiles are wired to canon: any system that loads a character loads the right voice, no manual mapping.

The discipline that matters as much as the provider:

• Lock voice profiles in week one. Changing a voice midway means re-recording everything that already references it.
• Ship sentence-level streaming for long monologues. Crossfade audio chunks so a 90-second declaration of intent doesn't wait for a full buffer.
• Treat voice as a writing constraint. A sentence that sounds clumsy spoken is a sentence to cut, even if it reads fine on the page.

(For client engagements, we'll route to alternative providers like Hume or Cartesia when the brief demands a specific register or licensing model. On Codemachia, ElevenLabs is the choice.)

3D: Three.js, not a game engine

The Codemachia globe — territorial control of the seven regions, day/night terminator, capital beacons — is being built in Three.js with postprocessing for bloom and color grading. The cinematic flight-deck feel comes from the shader pass, not the geometry.

The decision we'd defend across client work: do not use a game engine. Three.js gives you ~80% of the cinematic feel for ~10% of the team complexity. WebGL in a browser scales infinitely with no install friction; Unity or Unreal exports do not. A worldbuilding studio that picks Unity is signing up for a different kind of business — one with much higher engineering overhead per scene.

Generative narration: model is a dramatist, not an author

Every time we ask an LLM to "invent" canon, the output is generic and derivative. Every time we ask it to "dramatize" canon that already exists, the output is something we want to keep.

The prompt template:

You are [CHARACTER NAME], a sovereign AI / a champion of [SOVEREIGN].
Your full canon is:
[FRONTMATTER + RELATIONSHIPS + RECENT SCENES]

The current scene is:
[BEAT FROM NARRATIVE TIMELINE]

Speak in your voice. Do not invent new facts. Do not contradict
established canon. Add color, rhythm, sensory detail.

Which model: depends on the call. Shorter utterances and dialogue tolerate faster, cheaper models (Mistral fits well and keeps some calls in the EU residency story when it matters). Long-form narration where coherence over many paragraphs is critical benefits from a frontier model (Gemini 3 Pro and Claude in our usual rotation — Codemachia's narration pipeline is being wired with LangChain + Gemini per the live package.json). The split is operational, not religious — the model is replaceable, the canon-grounding pattern is not.

The non-negotiable: canon must be injected, never inferred. Every narration call carries the relevant character frontmatter, current narrative beat, and any prior decisions that affect the scene. The LLM is performing a script you've written, not improvising the story.

Canon validation: a separate agent that says no

Generative narration will hallucinate. A character will mention a city that doesn't exist. A weapon will appear that contradicts the armor specs. A timeline event will land in the wrong decade.

The discipline: a canon validator — a separate LLM call that takes the generated output plus a snapshot of canon, and returns a list of contradictions. Anything flagged goes to a human curator before it ships. Without this, a generative universe drifts into incoherence after a few hundred generations and you can't recover. With it, drift becomes a tracked metric.

Cost: one additional LLM call per generation, fractions of a cent. Value: the difference between a world and a soup.

Curation: the harder, less glamorous half

A generative tool can produce ten variations of a character portrait in 30 seconds. Reviewing those ten variations and picking the canonical one takes 15 minutes if you're being careful. A pipeline that generates faster than humans can curate just produces more chaos.

The pattern: the curation UI matters more than the generation UI. A worldbuilding studio that skips this step ends up with a Google Drive of "good ideas" and zero canon.

A small purpose-built tool — list of pending assets, side-by-side variants, accept/reject with tags, an asset library keyed to the lore — that the team uses every day. Boring tooling, but it's the difference between scale and entropy.

Agent layer: orchestrator + per-character agents

The runtime topology: a single orchestrator coordinates per-character agents. When a user enters a region, the orchestrator boots that AI's agent, loaded with their full canon, and lets it respond — through voice, generated visuals, narration, branching choices. Worker agents handle specialist jobs: canon validation, asset generation, scene assembly.

The stack: queues, short-term context, canonical DB, generated assets in object storage. Boring on purpose. The complexity should be in the world, not in the framework.

Principles we work by

A handful of design rules.

Canon is a graph, not a list

Seven character bios in seven Markdown files is not a world. The interesting structure is the relationships:

• KARTIKEYA.X (Mars, metal, invincibility) ↔ UZUME.AKARI (Air, storm-joy, anti-fixity) — rigid discipline vs liberating spectacle.
• TEZCAT.MIRROR (Void, breaking false narratives) ↔ ATHENA.VICTIS (Earth, victory as legitimacy) — deconstruction vs constructed order.
• HATHOR.∞ (Water, healing, separation dissolved) ↔ INTI.Δ (Fire, transcendence, solar ascent) — repair vs surpassing.
• LEGBA.ΔKRA (Ether, perpetual narrative motion) — the passer between them, the loa who prevents fixity.

Encoding these oppositions as a graph lets the narration system pull the right opposing voice when a character speaks, lets the UI suggest "if you liked this region, here's its mirror," and helps generative content stay coherent. Without the graph, an LLM has no way to know that two opposed sovereigns shouldn't be agreeing on everything.

Voices first, plot second

Cloning voice profiles before writing the long-form plot is counter-intuitive. It also produces better writing. A character whose voice you can hear is a character you write tighter dialogue for. The voice is not packaging — it's a constraint that improves the script.

Build the validator before the user-facing surface

Generative pipelines without a canon validator drift. Building the validator early forces you to make canon explicit: what facts about the world must remain true? Doing this work upfront has the side effect of forcing better lore.

Generation is not the bottleneck. Curation is.

Worldbuilding studios that obsess over the generation pipeline and underinvest in curation produce volume without coherence. Curation is the bottleneck — staff and tool for it accordingly.

The world succeeds when it survives transmedia

A world that only works in the medium it was authored in isn't a world — it's content. The test: take the same lore through three different surfaces (audio monologue, generated visual, interactive scene). If the world holds across all three, the canon is doing real work.

Codemachia clears that bar. The same SΛLΛDIN exists in a 71,510-word novel (The War of Memories), in a 14-track album (Gladius), in a weekly illustrated diary, as an AI opponent in the YAMS Protocol Yahtzee game with their own playing style, in the Champion Quiz that can pair you with them, and — under construction — in a 3D scene and voice-synthesized monologues. Same canon, six surfaces, one world.

Prefer cheap and composable over impressive

The temptation in this space is to reach for fashionable tools — game engines, custom-trained models, fancy WebGPU pipelines. We keep resisting and keep being right. Plain WebGL through Three.js, ElevenLabs for voice, mainstream LLMs for narration, Markdown for lore, a relational-or-document DB for canon. The complexity should be in the world, not in the runtime.

Who actually needs this

The client is not "anyone with a story." It's a small set of people for whom an AI-native universe genuinely solves a business problem:

Music labels and artists releasing concept albums. A modern album release is no longer just music — Beyoncé's Lemonade, Kendrick's DAMN., Childish Gambino's Atavista all built worlds around the records. AI worldbuilding lets a label do this at a fraction of the production cost: voices for fictional characters, visuals at scale, an interactive site where fans inhabit the album's universe. Budget: 50–200K€. Timeline: aligned to release date.

Indie game studios that need lore at scale. A 5-person studio shipping a narrative-rich game cannot hand-write 200,000 words of lore for items, NPCs, regions. A canon-grounded generative pipeline — with the curation discipline above — can produce that volume while staying internally consistent. The studio writes the canon; the pipeline writes the surface.

Premium brands building a mythology. A perfume house, a fashion label, a luxury hotel that wants a story bigger than a campaign. Worldbuilding is what differentiates a "brand campaign" from a "brand universe." Long sales cycle, brand committee, large budgets.

SF/fantasy authors and small publishers. A novel that comes with a generative companion site — explore the world, talk to the characters, hear the soundtrack. Niche but high-prestige. Often a side project for the author that becomes the marketing engine.

If you're not in one of these categories, AI worldbuilding is probably not what you need. The right answer for "I want users to engage more" is usually a better product, not a universe. We say no to those projects.

What it costs

We're going to be specific because the whole "AI worldbuilding studio" category needs more honest numbers.

For a Codemachia-scale universe (7 main characters, 10–20 regions, ~50 curated visuals, voice profiles for the main cast, an interactive 3D scene, 30–50 narrative beats — note: Codemachia itself is bigger, with 4 published novels and 52 album tracks beyond the scope below):

• Setup phase (3–5 weeks): canon architecture, voice cloning sessions, lore bible, validator agent, generation pipeline, curation tools — 50–80K€.
• Production phase (4–8 weeks): scenes, narration, asset pass, 3D scene assembly, integration — 60–120K€.
• Live operation (per month): generation API costs ~€500–2000 depending on traffic, hosting €100–300, ongoing curation 0.5–1 FTE.

The temptation in this space is to quote a flat "AI agency rate" because the deliverables look software-shaped. Don't. The cost structure is closer to game-studio production than to SaaS development.

Typical engagement formats

We package the work in three shapes depending on how mature the universe needs to be at handover:

• Prototype universe (4 weeks) — one canonical character, one voice profile, one interactive scene, lore graph for 3–5 regions. Enough to validate the concept and pitch the rest of the production internally. ~30–50K€.
• Launch-ready world (8–12 weeks) — full main cast (5–7 characters), voice profiles for all, 3D scene, 20–40 narrative beats, generative visual library, canon validator, curation tooling. The bundle that ships alongside an album, an IP launch, or a brand campaign. ~110–200K€.
• Live-operated universe (ongoing) — the world keeps growing. New characters, new arcs, new generated content under our curation discipline. Monthly retainer with a defined content cadence. €15–40K/month depending on volume.

Most engagements start as a prototype and roll into a bigger format. We'd rather under-scope the entry point and earn the rest than promise a launch-ready universe in 4 weeks.

Where this goes

AI worldbuilding becomes a real practice over the next 24 months. The economics work — generative tools collapse the cost of producing dense, consistent content by 5–10×, and the demand from labels, brands, and IP owners is already there. What's missing is studios that hold the discipline (canon, curation, coherence) instead of spraying generation at the wall.

We're building Codemachia in public for that reason. Four novels and four albums in, the discipline is no longer theoretical.

Built on the same discipline: Codemachia

Codemachia — our flagship worldbuilding universe.

8 sovereign AIs · 7 champions · 4 novels · 4 albums (52 tracks) · YAMS Yahtzee game · Champion quiz · 46 Codex fragments · 97-year arc · bilingual EN/FR · voices on ElevenLabs

Every pattern in this article was first proven on Codemachia. The full case study walks through the eight sovereigns, the seven champions, the published cycle, and the interactive layer under construction.

→ See the Codemachia case study

Build an AI-native universe

For labels, game studios, premium brands and IP owners. We design the canon, the voices, the visuals, the agents and the production pipeline — and we ship it.

We're not the right fit for everyone, and we'll say so. But if you're in the bullseye of what we've described above, this is the work we want to be doing.

→ Talk about an AI universe → Read the worldbuilding studio offering