What is LoreWeaver Director? A Starter Guide for Game Designers

LoreWeaver Director is runtime AI middleware for games. It runs either fully on-device, in the cloud, or a hybrid between the two. It reads and writes game state, and can generate narrative content while a game is being played. It's not an NPC chatbot. It's not a cloud service. It's not a replacement for your game logic. It's a system that sits alongside your game and participates in what's happening.

This article is a starter guide for game designers and developers who want to understand what Director actually does and how it changes the way you build a game. No architecture deep dives. No code. Just the mental model you need to start thinking about Director as a design tool.

The two layers

Director has two distinct layers, and understanding the separation is the first step to working with it.

The core is a general-purpose runtime that can read any game state variable you expose to it and modify any game state variable you give it permission to change. NPC relationships, faction standings, quest states, world events, dialogue, item placement, weather, prices, NPC schedules. If it's in your game state, the core can work with it. The core is reactive. Something happens in the game, the core responds by changing state.

The plot module is built on top of the core. Where the core is reactive, the plot module is proactive. It watches world state and decides when something should happen without waiting for the player. It generates narrative content: plot threads, quests, events, story arcs, character motivations, dialogue beats. It then uses the core to write those generated things into the game as real state changes.

Think of it this way:

What the core does

The core is the foundation. It's the part of Director that makes everything else possible. You decide what game state to expose, you decide what the AI is allowed to change, and the core handles the reading, writing, and validation.

A few examples of what the core can do:

• An NPC who remembers what you did three sessions ago. The core reads the world memory of past events, and when you walk into the tavern, it updates the bartender's mood and dialogue based on what it finds.
• A reactive economy. The core watches player purchases, scarcity events, and faction control. When a supply route gets disrupted, it adjusts prices at affected vendors. Not through scripted events, through direct state changes based on current conditions.
• Adaptive difficulty that reads player behavior. Not a slider. The core watches how you play, reads your stats, your success rate, your hesitation patterns, and adjusts encounter compositions or enemy behavior configs.
• Context-aware dialogue. The core reads the state of the current scene, the player's recent actions, and the character's current goals, then generates dialogue that fits. Not from a pre-authored tree. Generated on the fly, within the constraints you defined for that character.

All of this is reactive. Something happens, the core responds. You're still in control of the game loop. You're still driving. The core is a passenger who can change things if you let it.

What the plot module does

The plot module is the part that gets people excited, and it's also the part that needs the most careful framing. The plot module is proactive. It doesn't wait for the player to trigger something. It watches the world and decides when a story should happen.

This is where emergent narrative comes from. The plot module generates plot threads, events, quests, and story developments based on what's actually going on in your game world.

Examples:

• A faction war that breaks out because you helped the wrong merchant, which shifted economic power, which destabilized a faction alliance, which the plot module picked up as a narrative opportunity. None of that was pre-written. The plot module read the state, recognized a story worth telling, generated the event, and used the core to write it into the world.
• A CK3-style personal event. Your character's rival is spotted in the same district. The plot module generates a confrontation scene, writes the encounter state, creates the dialogue options, and lets you play through it. Next playthrough, your rival might be in a different city and never confront you at all.
• A quest that appears because the world made it make sense. You've been robbing merchants in the Warrens for a week. The plot module reads the pattern, generates a bounty hunter quest where someone has been hired to find you, spawns the NPC, writes the encounter, and now you have a problem you didn't see coming.

The key thing: the plot module doesn't just generate text. It generates narrative content and then uses the core to make that content real by modifying game state. Spawning the NPC, adding the quest, shifting the faction standing, creating the world memory entry. The story is written into the game, not just displayed on top of it.

Why the separation matters

You can use the core without the plot module. If all you want is an AI that can adjust game state reactively and intelligently, you don't need proactive narrative generation. Lots of games would benefit from just the core: adaptive NPCs, reactive world state, context-aware dialogue. No plot generation needed.

You can't use the plot module without the core, because the plot module needs somewhere to write its output. The core is how the plot module affects the game world. Without it, the plot module would just be an idea generator that couldn't actually do anything.

This separation matters for design reasons too. The core has smaller, more predictable concerns. You're defining what variables it can touch and what constraints apply. The plot module is a much larger design surface. You're defining what kinds of stories should emerge from your world, what constraints make them coherent, what scale of events is appropriate. The two layers ask different design questions, and treating them as one thing leads to muddled answers.

How Director changes your design process

If you're used to authoring every event, dialogue line, and quest by hand, working with Director requires a mental shift. You stop writing specific content and start writing the rules and constraints that let content emerge.

With just the core, the shift is moderate. You still write most of your content. Director adds reactivity on top. You're designing what can change, under what conditions, within what bounds.

With the plot module, the shift is larger. You stop thinking "what happens next?" and start thinking "what kinds of things should happen in this world, and what makes them coherent?" You design the shape of the world, the factions that exist, the motivations that drive characters, the constraints on what the plot module is allowed to generate. Then you let it generate.

This is closer to how CK3 or Dwarf Fortress designers work than how traditional narrative designers work. You're designing systems of emergence rather than authoring specific stories.

The tradeoff is real. You give up some control over specific moments. You gain a world that can surprise both you and the player. Whether that tradeoff is worth it depends on what kind of game you're making.

What's important to mention here is that you decide how much control you give up and how much creative freedom Director has. If you want a game with 90% scripted narrative and only a couple of emergent side quests, that's possible. If you want it the other way around, where you have a couple of key scripted plot points and let Director handle the rest, that's also possible.

Where to start

If you're thinking about using Director in a project, here are the questions to ask yourself before touching any code:

• What game state do I actually want Director to see? Not everything needs to be exposed. Start small. Pick the systems where reactivity or emergence would add the most value.
• What am I willing to let Director change, and what stays hand-authored? Combat math, economy balance, difficulty curves, and probability systems probably stay mechanical. Narrative content, NPC reactions, dialogue, and world events are where Director earns its place.
• What constraints define a coherent world in my game? If the plot module is going to generate events, it needs to know what kinds of events fit. What tone, what scale, what stakes, what's off-limits. This is the design work that replaces content authoring.
• Where do I want to start? You can use just the core at first. Add reactive AI to a few specific systems. Get comfortable with the mental model. Move to the plot module when you understand what you want from it.

What's next in this series

This is the first article in a series about designing with Director. Upcoming articles cover specific topics in more depth:

• The action spaces Director operates in, and how you define them
• The advisor pattern for keeping AI decisions under human control
• Validation and trust boundaries between AI and your game mechanics
• Where AI doesn't belong (and why combat stays mechanical, for now)
• Designing events that feel authored but respond to world state
• Latency and speculative generation for making real-time AI feel instant

Start with the mental model in this article. The rest builds on it.