Mechanics

Tapestria is a text-driven tabletop RPG. There is no map you click on, no combat grid, no dialogue tree. You type what your character does, and the world reacts. The reaction is the product of a parser that turns your text into a structured intent, a deterministic rules engine that resolves the mechanical part, a narrator that writes prose around the result, and — when a quest terminates — an aftermath pass that commits the durable consequences.

This page is the player-facing version of that loop.

The session loop

A session is a single sitting with your party — one or more characters under your control — in Aethernia. Sessions can be picked back up later; the world and your characters persist.

A single turn looks like this:

1. You type. Free text. "I head to the Tarnished Flagon and look for the bard", "I attack the guard with my longsword", "I cast detect magic on the chest". No commands, no slash-syntax.

2. The parser reads your intent. Behind the scenes the parser maps your text to an action_type and a set of entity IDs from the current scene — the NPCs, items, locations, monsters around you. This is where free text becomes something the rules engine can act on. If you reference an entity that's not in scope ("I attack the king of Luminastria"), the parser can't bind it and your action gets gently redirected.

3. The engine resolves. If the action implies a roll — a skill check, an attack, a save — the rules engine resolves it deterministically against the D&D 5e SRD. Dice are real, modifiers are real, conditions and effects apply per RAW. The LLM cannot fudge a hit. Skill checks come in two flavors: pre-determined ones derived from the scene's graph state (a lying NPC implies an Insight check is available; a hidden NPC implies Perception), and free-form ones the parser requests when a player's narration plausibly calls for a roll the scene didn't pre-encode. Either way the engine resolves the roll; the LLM only narrates the outcome.

4. The narrator writes the scene. Given the engine's result and the relevant world state, the narrator produces a few paragraphs of prose that describe what happens. When you addressed an NPC, an impersonator subroutine fires first — hermetic to that NPC's own knowledge, so the NPC responds from what it knows, not from what the scene's omniscient context contains. The narrator then weaves the NPC's response into the surrounding prose. Any world changes proposed at this stage — an NPC's disposition shifting, an item moving, a quest advancing — go through a separate validation layer before they're committed.

5. The world updates. Validated world changes are appended to an immutable event log, then applied to the world model. The change is real for everyone, including you next session.

6. Aftermath, when a quest ends. Completing or failing a quest triggers a separate aftermath call that authors the durable cross-session consequences — the canonical graph commit for that quest type, plus the disposition shifts, NPC moves, and knowledge updates that come from the quest's outcome. This is what makes "the world remembers" mechanical: every quest leaves a deliberate, typed footprint future sessions read against.

A turn is a few seconds of typing and a few seconds of waiting, depending on the model and the action complexity.

What carries over

Across turns in a session: combat state, initiative, hit points, conditions, what the NPCs around you know, what items you're holding, your reservation on locations / NPCs (so two parties wouldn't simultaneously interact with the same scene — although today only one party is ever active).

Across sessions: everything that hit the event log. Your character's level, inventory, knowledge. The state of NPCs you interacted with. Locations you discovered or changed. Quests you advanced. Reputations, factional dispositions, lies you told and whether the listeners caught them. If you killed an NPC, that NPC is dead. If you persuaded a governor to step down, the governor stepped down. These persist for every future session — yours and, eventually, other players' too.

There is no save-and-reload. There is no "I'll redo this turn." The world remembers.

What the rules are

The rules of resolution are the D&D 5e SRD. Specifically:

• Dice and modifiers — d20 + ability mod + proficiency where it applies. Critical hits, critical fails, advantage and disadvantage. All the usual mechanics.
• Skills — Athletics, Acrobatics, Persuasion, Insight, Investigation, Perception, Stealth, etc. Each tied to its ability score.
• Combat — initiative, turn order, attack rolls, damage rolls, saving throws, conditions (poisoned, frightened, restrained, prone, ...), effects (bless, bane, hex, ...).
• Spells — SRD spell list with full mechanical effects. Concentration, slot consumption, components.
• Leveling — XP-based, SRD class progression.

The classes you can pick come from the SRD core: Barbarian, Bard, Rogue, Wizard, Ranger, Paladin. We're starting here deliberately — D&D 5e is the most familiar TTRPG framework, the SRD is fully open, and "the AI can't change the rules" is much easier to make true when the rules are someone else's that we just implement.

What we don't do: invent custom rules, homebrew mechanics, or let the LLM "DM-fiat" outcomes. If a check would be impossible in 5e, it's impossible here. If a check is possible in 5e, the same dice and modifiers apply.

What the AI does (and doesn't)

The LLM is allowed to:

• Narrate the scene. Word choice, mood, pacing, the way an NPC speaks.
• Make judgment calls that are inherently subjective. "Does this argument count as persuasive enough to lower the DC?" The narrator can read the situation and decide. But the DC was set by the engine, the roll happened in the engine, and the outcome was decided before the narrator wrote a word.
• Propose world changes that follow from the scene. "After being insulted in front of the court, the Captain's disposition toward you drops." This proposal goes through the mutation validator before it's committed — the LLM cannot just edit the world.

The LLM is not allowed to:

• Change your stats, give you items you didn't earn, take items you didn't lose.
• Decide whether a roll succeeds. The roll already happened.
• Invent NPCs that don't exist. Every NPC in the narration corresponds to a graph entity.
• Reference world facts that aren't in its context window. If it doesn't know about a faction, it doesn't make one up.
• Cite a rule that's not in the SRD.

When the LLM tries to do any of the above (and they do try, occasionally), the mutation validator rejects the change and the narrator gets re-prompted. After three consecutive rejections on the same turn, the player gets a soft "the world resists" message and we move on with what did validate.

What Tapestria isn't

These are scope decisions, not omissions:

• No direct cross-party scenes. You and another player won't meet face-to-face in Aethernia. What you share is the world — the governor I deposed is deposed in your game too — not the moment. This is what makes a coherent shared persistent world tractable for an AI narrator: the world is canonical and durable, but every session is a single party's perspective on it.
• No voice or audio. Tapestria is text-driven by design. Reading and writing prose is the medium; we're not building voice acting on top.
• No tactical visuals. No combat grids, no battle maps, no portraits, no rendered scenes. The mental image is yours; the engine and narrator give you the structured information your imagination needs.

Read deeper

• The Shared World page goes into what "shared persistent world" actually means in practice, with examples.
• Gameplay as Graph Mutation is the design lens behind why the loop has this shape — world as graph, gameplay as graph mutation, NPCs as protagonists and PCs as operators.
• The Architecture section explains the systems the loop runs on.
• The LLM Pipeline page details the parse → engine → narrate split that lets us say "the AI can't hallucinate the rules" with a straight face.