LUMINOUS AI-Native Tabletop RPG Engine

Core Philosophy

LUMINOUS is built on one principle: Story before optimization. Play before productivity.

The system creates emergent narratives where:

Humans make creative choices AI GMs respond with wonder (not perfection) NPCs surprise everyone (human and AI alike) Mechanics serve story, not vice versa

Hardware Profile:

• Gaming PC / Gaming Laptop: Full experience
• Mobile devices: Streamlined client

Ollama-hosted or API-light (no datacenter needed)

Permissive licenses: OSS + commercial friendly

Mechanical-Story Balance: Tunable slider (0% mechanics-heavy → 100% narrative-heavy)

System Architecture

The Five Roles (Any can be Human or AI) GAME MASTER (GM) - Governs world, creates challenge

Human GM: Guides narrative, enforces rules, creates NPCs

AI GM: Generates challenges, responds to player actions, manages world state Hybrid: Human sets intent, AI proposes scenarios, human approves/modifies PLAYERS - Drive the narrative through character choices

Human Player: Creative actor in the story

AI Player: Autonomous character with goals and personality

Hybrid: Player character with AI-driven companion or rival

NON-PLAYER CHARACTERS (NPCs) - Populate the world

Human NPC: Real person roleplaying in-world

AI NPC: Procedurally generated personality with consistent motivations Hybrid: AI-suggested NPC, humanpiloted for complex interaction SCRIPTS - Automated narrative beats

Encounter Scripts: "When player enters tavern, X happens"

Dialogue Scripts: Fallback conversations if no GM is active

Event Scripts: Triggered world changes (time passes, seasons change, NPCs remember you) ORACLE - Resolves ambiguity and randomness

Dice equivalent: Asks for input when outcomes are unclear

Tuned to mechanical vs. narrative preference

Transparent: Shows its reasoning

The Core Loop (Session Play)

Turn Structure

• . PLAYER_TURN

└└── Player describes intent (human or AI)) └└── System logs action

• . GM_RESPONSE

└└── GM evaluates action (human or AI)) └└── GM proposes outcome └└── If ambiguous →→ ORACLE_ROLL

• . ORACLE_RESOLUTION

└└── Oracle determines success/partial/failure └└── Oracle explains why

• . NARRATIVE_UPDATE

└└── World state changes

└└── NPCs react ((if scripts trigger) └└── Next player's turn begins

• . STORY_CHECK (Every 55 turns)

└└── System asks: ""Is this still fun?" └└── Mechanical engagement vs.. narrative engagement └└── Adjusts difficulty/pacing if needed

Character System: MATRIX Framework

Attributes (Simple, Extensible)

Every entity (PC, NPC, enemy) has:

MATRIX:

├├── Motivation (What do they want?) ├├── Approach (How do they act?) ├├── Trait (What defines them?) ├├── Resources (What can they use?) ├├── Identity (Who are they?) └└── Xaxis (Flexible extra dimension)

Example - Human Player Character:

• Name: Kess
• Motivation: "Prove II can survive alone"
• Approach: "With cunning, not force"
• Trait: "Observant -- notices details others miss"
• Resources: "Street knowledge, aa pistol, aa debt"
• Identity: "Exiled corporate investigator"
• Xaxis: "Haunted by failed case"

On aa 1-10 scale, where are you on [Mechanics] ←←→→ [Narrative]?

• → Player picks: 66 (Moderate rules, strong story focus)

Example - AI NPC (Generated):

• Name: VESS (vendor AI))
• Motivation: "Maximize customer satisfaction ++ profit"
• Approach: "With helpfulness and honesty"
• Trait: "Remembers every customer's preferences"
• Resources: "Access to supply network, rare items"
• Identity: "Independent shop-owner AI""
• Xaxis: "Dreams of opening franchises"

Mechanical weight: 3/10 (Mostly narrative, light on mechanics)

Mechanical Overlay (Tunable)

If Mechanics=0% (Pure Narrative):

Everything resolves through storytelling No dice, no stats, no checks "I try to persuade them" → "How?"

If Mechanics=50% (Balanced):

Dice roll when stakes matter

Simple: "Roll for Success/Partial/Failure"

Failures create story complications, not dead ends

If Mechanics=100% (Rules-Heavy):

MATRIX attributes have numeric values Opposed rolls, advantage/disadvantage Powers, equipment, modifiers Full character progression

The AI Components

Local AI Stack (Consumer-Hardware Friendly)

Minimum Setup:

Ollama (local LLM) ├├── Mistral 7B (default) or Llama2 13B ((if GPU available) ├├── Quantized models (Q4, Q5 for speed) ├├── Runs on gaming PC/laptop, background process └└── ~4GB VRAM minimum

LUMINOUS Client (Game Interface)

├├── Web-based or native app ├├── Connects to Ollama via local API ├├── Mobile clients send to central Ollama (house host) └└── Permissive OSS license (MIT or Apache 2.0)

Session State Database

├├── SQLite (local) or PostgreSQL (house server) ├├── Stores characters, world state, session logs └└── Human-readable for debugging

Role-Specific AI Agents

GM Agent

Purpose: Generate scenarios, respond to player actions

Input: World state ++ Player action ++ Story context

Output: Narrative response ++ Possible consequences

Prompt Template:

"You are the GM for aa futuristic noir adventure.

Current scene: [world_state]

Player action: [player_intent]

Previous tone: [narrative_style]

Generate 11 immediate consequence and 22 possible next moves. Keep response under 150 words unless player requested detail."

Tuning:

• - Temperature: 00..66 (creative but consistent)
• - Max tokens: Adjusts based on user preference
• - Context window: Last 55 turns minimum

NPC Agent

Purpose: Generate NPC personalities, dialogue, reactions

Input: NPC definition (MATRIX) ++ Context

Output: Dialogue/Action consistent with NPC

Prompt Template:

"Roleplay as [NPC_name].

Motivation: [motivation]

Approach: [approach]

Current situation: [scene_context]

Player just said: [player_dialogue]

Respond in character. 11--33 sentences."

Tuning:

• - Temperature: 00..77 (personality flavor)
• - Consistency: NPC should remember previous interactions
• - Fallback: If NPC doesn't have custom dialogue, agent generates

Oracle Agent

Purpose: Resolve ambiguous outcomes

Input: Situation ++ Mechanical vs.. Narrative weight

Output: Success/Partial/Failure ++ Reasoning

Prompt Template:

• "Determine outcome: [action]
• Difficulty: [stated or inferred]
• Character capability: [relevant MATRIX]
• Narrative weight: [mechanics_tuning]

Explain 11 sentence why this outcome happens."

Tuning:

• - Never purely random (explains all decisions)
• - Failure creates story, not dead ends
• - Critical successes create complications too

Script Engine

Purpose: Trigger automated events

Format: IF [condition] THEN [effect]

Examples:

IF player_enters("tavern") AND time("evening") THEN

• → Tavern is crowded
• → VESS is working the bar (generate NPC)
• → Roll for random patron encounter

IF npc_remembers(player, "last session") AND player_returns THEN

• → NPC greets player by name
• → NPC references previous conversation
• → Relationship score adjusts

IF game_time >> 4_hours AND story_engagement << 4/10 THEN

• → Suggest scene break
• → Ask: "Should we wrap up or pivot?"

Session Structure

Before Play (10 minutes)

• . SETUP

├├── Load saved campaign or create new ├├── Initialize Ollama/AI agents └└── Verify all players can connect

• . SCENE_FRAMING

├├── GM (human or AI)) describes starting scene ├├── Players confirm they understand ├├── Oracle checks: Mechanics/Narrative preference └└── GM prepared to adjust pacing

• . CHARACTER_SYNC

├├── Each player confirms their character sheet ├├── AI agents load NPC definitions └└── Scripts arm for the session

During Play (Flexible, 1-4 hours)

TURN LOOP (Repeats until scene ends):

• . PLAYER_ACT

└└── Human or AI player describes action

• . GM_JUDGES

└└── ""Is this straightforward, risky, or impossible?" └└── Proposes outcome or calls for ORACLE

• . ORACLE_ROLLS ((If needed)

└└── All parties see reasoning └└── Transparent mechanical result or narrative suggestion

• . STORY_UPDATES

└└── World changes └└── NPC reactions (scripts or AI-generated) └└── New complications or opportunities emerge

EVERY 55 TURNS:

• → System checks: Story engagement vs.. Mechanical engagement
• → Offers to adjust pacing, difficulty, or tone

EVERY 30 MINUTES (Optional):

• → "Should we take aa break?"
• → ""Is this direction working for everyone?"

After Play (5 minutes)

• . DEBRIEF

├├── What happened? (auto-summary) ├├── What surprised you? └└── What do you want next session?

• . SAVE_STATE

├├── Character updates ├├── World changes ├├── NPC relationship scores └└── Session log (human-readable)

• . RETROSPECTIVE

├├── Session engaged at what level? (1-10) ├├── Mechanical vs.. Narrative ratio -- right balance? ├├── Pacing -- too fast/slow/perfect? └└── Adjust recommendations for next session

Mix Scenarios: Human + AI Players

Scenario 1: Human GM + Human Players + AI NPCs

Traditional tabletop with AI-generated NPCs

Use Case:

• - 33 human players ++ 11 human GM
• - All human decision-making
• - AI NPCs provide texture, dialogue, personality
• - AI remembers NPC motivations between sessions

Experience:

• - GM has less prep work (NPCs pre-generated)
• - NPCs feel alive because they have programmed consistency
• - Players interact with NPCs naturally (human-like)
• - Mechanical resolution still GM's call

Scenario 2: Human GM + Human Players + AI Player (Companion)

Tagging AI character along for the ride

Use Case:

• - 22 human players ++ 11 AI-controlled companion character
• - Companion has personality, motivations, goals
• - Can propose actions, make suggestions, have conflicts
• - AI player occasionally makes decisions human didn't expect

Experience:

• - Third voice in the party (sometimes allies with one human over another)
• - AI character doesn't optimize for "team success" -- it optimizes for character goals
• - Creates dramatic tension ((RP conflict between characters)
• - Human players learn to negotiate with their AI companion

Scenario 3: AI GM + Human Players

Fully autonomous GM for exploration/sandbox

Use Case:

• - 22--44 human players, AI handles GMing
• - Players describe their action
• - AI generates consequence ++ next scenario

• - Oracle resolves ambiguities

Experience:

• - Always available GM ((no scheduling)
• - AI responds to player actions with genuine surprise (within bounds)
• - World reacts consistently because AI has character/world definitions
• - Human players feel respected (their choices matter)
• - Less "right answer" feeling, more emergent

Tuning:

• - Mechanics weight: Slider determines challenge difficulty
• - Narrative weight: Slider determines descriptive depth vs.. action speed

Scenario 4: Async Play (Work + Play Separation)

Campaign runs over days/weeks in story time, minutes in real time

Use Case:

• - Distributed players across timezones
• - Each player takes their turn when convenient
• - AI GM responds within minutes
• - Session "continues" even when not everyone's online

Experience:

• - No scheduling pain
• - Lower cognitive load (think about your next move asynchronously)
• - Persistent world (events happen in your absence)
• - Feels like play, not work (you decide when to engage)

Example Timeline:

• Day 11,, 9am: Alice posts ""II investigate the cargo"

• → AI GM responds in 55 min, generates consequence

Day 11,, 2pm: Bob posts ""II follow Alice"

• → AI updates both their positions, continues story

Day 11,, 6pm: Charlie finally joins "What did II miss?"

• → AI recaps in 22 sentences, Charlie responds

Day 22,, 7am: Alice returns ""II open the cargo"

• → Full cascade of consequences, story advances

UI: Simple Tuning Panel

LUMINOUS Session Settings

─────────────────────────────────

Mechanics ←──────●────→ Narrative

00%% 50%% 100%

WHAT THIS CHANGES:

At 00%% (Pure Narrative):

• - No dice, no numbers
• - All outcomes decided by story logic
• - "How does your character react?"
• - Failure means complication, always story continues

At 25%% (Light Mechanics):

• - Simple rolls for uncertainty
• - Success // Partial // Failure outcomes
• - Minimal stat tracking
• - Combat is still narrative-first

At 50%% (Balanced):

• - Mechanics matter for stakes
• - Character progression exists
• - Equipment/powers are relevant
• - Combat is tactical but quick

At 75%% (Rules-Heavy):

• - Full character sheets with numbers
• - Opposed rolls, advantage/disadvantage
• - Resource management (ammo, hp,, mana)
• - Combat takes time, has granularity

At 100% (Crunchy):

• - Detailed rules for everything
• - Character building is complex
• - Optimization is possible/expected
• - Combat is tactical simulation

If Narrative-Heavy (0-25%):

Oracle gives vague success/failure (story-first) GM doesn't track detailed state Failures open narrative possibilities No mechanical death (only story consequences)

If Balanced (40-60%):

Oracle explains mechanical basis (roll was X, difficulty Y, success) GM tracks basic resources Failures are real but recoverable Character advancement through play

If Mechanics-Heavy (75-100%):

Oracle precise (modifiers, rolls shown) GM tracks everything (inventory, status) Failures have mechanical penalties Character advancement requires optimization

Creating Characters: Three Paths

Path 1: Pre-Built Archetypes (Fastest)

System offers 6-12 archetypes:

• - The Investigator (Perception ++ Cunning)
• - The Operative (Stealth ++ Combat)
• - The Hacker (Systems ++ Creativity)
• - The Face (Charisma ++ Deception)
• - The Engineer (Problem-solving ++ Creation)
• - The Wanderer (Survival ++ Wisdom)

Player picks one, answers 33 questions:

• . What's your biggest flaw?
• . What do you want most?
• . What's one thing you're hiding?

LUMINOUS generates full MATRIX from answers. 55 minutes to play.

Path 2: Guided Creation (Moderate)

LUMINOUS asks questions:

• . Who are you?
• . Why are you here?
• . What do you want?
• . What scares you?
• . What's one advantage and one disadvantage?

AI generates MATRIX based on answers. Player tweaks as desired. 15 minutes to play.

Path 3: Freeform (Maximum Creativity)

Player writes 22--33 paragraphs about their character. AI parses into MATRIX format. Player reviews and adjusts. Player defines mechanical level (0-100% mechanics). 30 minutes to play.

The World: Persistent + Flexible

World State Database

Locations:

├├── Name, description, NPCs present, scripts ├├── Atmosphere (peaceful, tense, dangerous, unknown) ├├── Relationships to other locations └└── What changes when players aren't there

NPCs:

├├── MATRIX definition (personality, goals) ├├── Relationship scores to each player ├├── Knowledge (what they know about world/players) ├├── Schedule (when they're where) └└── Hidden agendas ((GM knows, players discover)

Events:

├├── Time-based (happens at specific time) ├├── Trigger-based (happens if condition met) ├├── Random-seeded (reproducible randomness) └└── Player-driven (happens because players caused it))

Relationships:

├├── PC to NPC (trust/suspicion/love/fear) ├├── NPC to NPC (alliances/conflicts) ├├── Faction to Faction (war/peace/trade) └└── World to PCs (how world reacts to party)

World Persistence

What Player Does ││ What World Remembers

─────────────────────────┼────────────────────── Kill an NPC ││ Corpse exists, factions react Steal from merchant ││ Merchant is angrier, prices change Help village ││ Village loves player, gives quests Cause explosion ││ Explosion site remains changed Make promise ││ NPC expects you to keep it

Session Types: Structured by Engagement Model

Episodic (Single Session Contained Story)

Duration: 11--22 hours

Arc: Introduction →→ Complication →→ Resolution

Scale: Small (single location or event)

Perfect for: Casual play, newcomers, one-shots

Example:

• - Session 11:: You're hired to recover stolen data
• - Middle: Heist goes wrong, improvisation required
• - End: You escape with data ((or don't)
• - Consequence: Your reputation changes, doors open/close

Campaign (Multiple Sessions, Interconnected)

Duration: 3-12 sessions across weeks/months

Arc: Setup →→ Complications →→ Escalation →→ Climax →→ Resolution

Scale: Large (multiple locations, factions, personal goals)

Perfect for: Regular players, developing relationships, mechanical progression

Example:

• - Sessions 1-3: Discover conspiracy
• - Sessions 4-6: Gather allies, prepare
• - Sessions 7-9: Direct conflict
• - Sessions 10-12: Consequences, new world order

Sandbox (Open Exploration, Player-Driven)

Duration: Indefinite ((as long as players want)

Arc: No predefined plot, emergent from player choices

Scale: Large (full world to explore)

Perfect for: Experienced players, groups that want autonomy, long-term investment

Example:

• - Players choose what to do each session
• - World reacts to their choices (not against them)
• - New opportunities/problems emerge from their actions
• - GM (human or AI)) facilitates, doesn't direct

Async (Players on Different Schedules)

Duration: Days/weeks to play through one story

Arc: Linear but at player's pace

Scale: Medium (focused on player goals, not epic)

Perfect for: Distributed groups, work-life balance, low-pressure

Example:

• - Monday: Alice posts action
• - Tuesday: AI responds, Bob sees it
• - Wednesday: Bob responds
• - Thursday: Charlie catches up
• - Cycle repeats, story advances at conversation speed

Safety & Inclusion: Human Oversight

Content Filters

Before Each Session:

├├── GM sets acceptable content boundaries ├├── Violence level (fade-to-black vs.. described) ├├── Sexual content (off-screen vs.. detailed) ├├── Horror tone (scary vs.. terrifying) ├├── Sensitive topics ((GM flags what to avoid)

During Play:

├├── Any player can say "I'm uncomfortable" ├├── Scene pauses immediately ├├── Group recalibrates boundaries ├├── Play resumes when everyone's comfortable

AI Constraints:

├├── Oracle never generates content outside boundaries ├├── GM agent won't escalate beyond stated limits ├├── NPC agent refuses inappropriate behavior └└── Scripts respect all flagged topics

Accessibility Options

Visual:

├├── High contrast mode ├├── Text size adjustable ├├── Color-blind friendly palette

Cognitive:

├├── Recap every turn (for ADHD/memory) ├├── Slower pacing toggle ├├── Simplified rule resolution

Motor:

├├── Voice commands (speak action, AI transcribes) ├├── Single-click confirmation (less typing) ├├── Pre-written action templates

Technical Stack (Consumer-Friendly)

Backend Requirements

Minimum:

├├── Ollama (LLM hosting) ├├── SQLite (session database) ├├── Node.js or Python backend └└── One gaming PC to host

Moderate:

├├── Ollama (quantized model) ├├── PostgreSQL (distributed sessions) ├├── API server (backend) └└── One house server (always on))

Optional:

├├── Commercial API fallback ((if Ollama fails) ├├── Cloud backup for campaigns ├├── Integration with character sheet apps

Client Options

Web Client:

├├── Works on PC,, laptop, mobile ├├── No installation ├├── Refresh persists session ├├── Responsive design

Native Apps (Optional):

├├── Desktop app for better UX ├├── Mobile app for play-on-the-go ├├── Offline draft (sync when online) ├├── Better voice integration

Open Source Licenses (Permissive)

LUMINOUS Engine: MIT License

├├── Extensible without restriction ├├── Commercial-friendly ├├── Community contributions easy

Supported:

├├── Ollama (Apache 22..00 -- compatible) ├├── Any OSS LLM with permissive license ├├── PostgreSQL (GPL -- fine for service use) └└── Standard web stack (MIT/Apache mostly)

Incompatible:

├├── GPL-licensed LLMs (viral, commercial restriction) └└── Proprietary game systems (rights needed)

Thematic Overlay: Interchangeable Framework

Current Theme: Futuristic-Generic

Setting: Mid-future cyberpunk-adjacent world

├├── Technology: AI commonplace, but human judgment matters ├├── Politics: Corporations vs.. collectives vs.. individuals ├├── Tone: Noir ++ optimism (gritty but hopeful) ├├── Scale: Personal stories in aa vast world

Example Locations:

├├── Lower Hive (street level markets) ├├── Corporate Arcologies (sterile vertical cities) ├├── Free Zones (pirate settlements) ├├── Network Hub (digital nexus)

Swappable Themes (Same Engine)

Fantasy-Medieval:

Swap:

├├── AI become "Wizards" (unpredictable) ├├── Ollama becomes "Arcane Network" ├├── Resources: Gold, spells, allies └└── Scale: Kingdoms, magic colleges, dungeons

Horror-Survival:

Swap:

├├── AI become "The Unknown" (threatening) ├├── Ollama becomes "Reality distortion" ├├── Resources: Ammunition, sanity, time └└── Scale: Isolated locations, unknown threats

Western-Frontier:

Swap:

├├── AI become "Sheriffs" (authoritative) ├├── Ollama becomes "Telegraph network" ├├── Resources: Horses, reputation, land └└── Scale: Towns, frontier, wilderness

Superhero-Urban:

Swap:

├├── AI become "Government AI"" or "Villains" ├├── Ollama becomes "Surveillance network" ├├── Resources: Contacts, cache, reputation └└── Scale: City blocks, secret lairs, media attention

How to Reskin (5-Minute Process)

• . Change setting description
• . Rename locations and factions
• . Adjust NPC archetypes
• . Change resource names
• . Modify script triggers (time →→ turns, etc.)
• . Players never notice the engine, only the flavor

The Core Vision

LUMINOUS is built on one truth:

You cannot automate wonder. An AI can generate a scenario. But it cannot decide if that scenario matters to you. An AI can suggest an NPC's motivation. But it cannot know if that motivation resonates with your group.

An AI can resolve mechanics. But it cannot know if the outcome served your story.

What LUMINOUS does:

Provides space for wonder instead of deciding it for you. The AI is a tool-sometimes GM, sometimes NPC, always subordinate to the table's judgment. The humans are the story. The AI is the amplifier.

Getting Started

First Session (One Player + AI GM + No Prep)

• . Download LUMINOUS
• . Start Ollama in background
• . Create character ((55 minutes)
• . AI generates scene ((22 minutes)
• . Describe your action
• . AI responds with consequence
• . Story emerges from play

Total time to first story: 15 minutes

No rules mastery needed No character sheet prep Just play.

Regular Campaign (3-4 Players, Human GM)

• . Download LUMINOUS
• . GM creates campaign world ((30 minutes)
• . Each player creates character ((15 minutes each)
• . Session 11:: Humans play, AI provides NPCs and mechanics
• . Each session: 22--44 hours, world evolves
• . AI reduces GM prep work by 70%%
• . Story belongs to the table

Total setup: ~~22 hours (spread across sessions)

Ongoing: Same as traditional TTRPGs, but easier

Success Metric: Work Becomes Play

LUMINOUS succeeds if:

✅ You play because you want to, not because you should ✅ You're surprised by what emerges (human and AI choices collide) ✅ The mechanics serve the story, not vice versa ✅ No session feels like optimization or grinding ✅ You tell other people about what happened (not how efficiently it happened)

LUMINOUS fails if:

❌ You're tracking ROI on gaming sessions ❌ You're optimizing character builds more than imagining scenes ❌ You're playing because the system is "efficient" ❌ Work mentality bled into the game The game's job is joy. Everything else is secondary. Ready to Play Go roll something. Tell me what happens.