Gameplay as Graph Mutation

Most "AI RPG" projects start from a question like how can the LLM tell a better story? Tapestria starts from a different one: what is a story, mechanically? The answer we settled on is the thesis behind almost every architectural choice in the system — and the one that makes the rest of these docs hang together.

The world is a graph. Gameplay is a sequence of mutations on that graph. NPCs are protagonists; PCs are operators.

Two scales of mutation

Almost everything that happens in the world falls into one of two shapes:

Quests are composite, durable graph commits. Multi-beat. Persisted on completion. They change the shape of the world. A successful heist transfers ownership of an item from one NPC to another (or to the player party). A successful diplomacy quest shifts the stance between two factions. A successful exploration quest adds new locations to the map and the connections between them. Quests are how the world's shape changes.

Skills, abilities, and spells are atomic operators. Single check or single cast. Reads, small writes, concealments. Most resolve within a turn. They're how the player queries and nudges the world between the big commits.

The two scales share state in both directions:

• Skills gate quest offers. An NPC won't ask a stranger to fetch their daughter's locket; the strangers needs to be trusted first. The disposition layer (which Persuasion and Insight read against, and Persuasion tilts) is what unlocks the quest offer. That layer is just edges on the graph.
• Skills shortcut quest resolution. A successful Persuasion on the gate guard turns a heist beat from "infiltrate the back" into "walk through the front." A successful Insight on the lying witness collapses an investigation step. Skills don't bypass quests; they reshape their cost.
• Quests change what skills can access. After a schism-quest commits a new doctrinal stance on a faction, Insight on that faction's NPCs reveals a different layer than it would have pre-quest. The mutation a quest persists is the substrate skills then read against.

This bidirectional coupling is the load-bearing reason skills and quests live on the same graph instead of being parallel systems.

NPCs are protagonists, PCs are operators

A subtle inversion from how most CRPGs think about agency. In a traditional CRPG the player is the protagonist and the world is scenery. In Tapestria the NPCs (and the factions they belong to) want things — those wants emit quests. The player executes against those wants, and successful execution advances the issuing NPC's and faction's interests. The story is the accumulation of advanced interests across all NPCs and factions over time.

The reason the wants come out of the NPCs and not the player is, in lore terms, also the reason post-collapse Aethernia exists the way it does. Every NPC who matters is tied to something — a faction, a guild, a debt, a long-running watchfulness with someone they cannot afford to provoke openly. Moving on their own desires would commit them publicly to a direction the rest of the system would notice. A player has none of those entanglements yet. A player can ask questions that an Ordo scholar can't ask without becoming an Ordo scholar asking questions, can walk into a room a Tenebres cell would never walk into, can carry a parcel a Regency clerk could never be seen carrying. That's what the player is, in the world's view: someone whose movements have not yet acquired meaning, and can therefore still be borrowed.

The player is essential, but they're the verb — not the noun.

Why the LLM narrates but doesn't mutate

This thesis is what makes the LLM Pipeline architecture cohere. If gameplay is graph mutation, then:

• Mutation choice is mechanical, not narrative. Which graph operation a successful Persuasion produces is defined by the operator catalog; the LLM doesn't get to pick it.
• The LLM authors the narration of mutations, not the mutations themselves. The narrator describes the door swinging open after a successful Sleight of Hand on the lock; the engine has already produced the write that unlocked it.
• Validation is the bouncer. When the LLM does propose mutations (the narrator and the planned aftermath call both can), every proposed mutation is type-checked, entity-checked, and allow-listed before it commits. The LLM cannot invent operations the catalog doesn't have.

This is also why "skill check as graph operator" is the framing, not "skill check as DC roll." A DC roll is a probability event; an operator is a typed mutation. The roll determines whether the operator fires; the operator determines what changes when it does. That separation is what makes the system auditable — at any point you can ask "what changed?" and the answer is a list of typed mutations in the event log.

What the catalog covers

Mapping a skill or spell to a graph operator means picking which of four primitive shapes the action takes:

• Reads project a typed slice of the world back to the player. Insight reads NPC attitudes and faction allegiances. Investigation reads physical evidence at a location. Perception reads hidden items and hidden exits. Arcana reads active magic effects on an entity. Each read is constrained to what's actually there — there's no "the LLM made up a clue" failure mode.
• Soft writes apply session-bounded overlays that decay rather than persist. A successful Persuasion tilts an NPC's disposition by a bounded amount; the overlay sits on top of the durable layer and resolves out at session end. The effective disposition is the sum of the durable layer and the overlay.
• Hard writes commit durable mutations to the world. A successful Sleight of Hand transfers ownership of an item from an NPC to the player party — the mutation is real and persists across sessions. Spells like Find Familiar spawn persistent companions; Knock removes the locked state of a door or chest; Goodberry creates short-lived items that decay on their own.
• Concealments temporarily hide facts that would otherwise be visible. Fog Cloud blocks line of sight in an area; Protection from Evil and Good blocks certain creature-class effects on the protected target; Stealth conceals the player's actions from witnesses who'd otherwise record them.

The same skill against different target types can be a different operator — Arcana on an NPC reads active effects on the creature, Arcana on a Location reads active effects on the area, Arcana on an Item reads magical properties. The parser dispatches on (skill, target).

Spells map more decisively than skills because each spell has a precise effect spec, and they pay a resource cost — a spell slot — that justifies being hard writes where skills are mostly soft nudges. Dominate Person is a hard temporary disposition override; Persuasion is a probabilistic tilt. The cost asymmetry is the design lever — spells are how a player pays to bypass the soft-influence layer.

What this means for design: the question for every new skill, spell, or ability isn't "what does it do narratively" — it's "which operator shape, on which target type, with which resource cost." If an action's effect doesn't resolve to a defined graph operation, it's flavor, and flavor is fine — it just doesn't get rolled for.

How this changes the player experience

In a CRPG with handcrafted content, every "you can do X here" was decided by a designer who put a flag on the location, NPC, or item. In Tapestria, "you can do X here" emerges from the graph state at this moment — what NPCs are present, what they know, what their dispositions are, what the location's properties are, what active effects are in scope. Skills aren't a menu of options; they're operators the player can apply to whatever's in scope.

The result is that a player who's never seen a particular scene before can still know roughly what they can do, because the operator catalog is consistent across the world. Persuasion always tilts disposition. Investigation always reveals physical evidence at a location. Insight always reads NPC attitude toward the party. Players learn the operator catalog the same way they learn the SRD — once, then it generalizes.

That generalization is what we mean when we say the world is "real" — there isn't a hidden flag system underneath that decides whether your action will work. There's just the graph and the operators that act on it.

Read on

• The LLM Pipeline describes how the parse → engine → narrate → aftermath sequence implements this lens, including the impersonator subroutine for in-character NPC voices.
• The Architecture overview explains why a graph world model, why an event log, why the rules engine is its own isolated layer.
• The Shared Persistent World page shows what this looks like across multiple sessions — the mutations from one player's choices becoming the world another player inherits.