Four faces turn to you, waiting. You have no idea who Garrick is.

You invented him three sessions ago—a blacksmith, a grudge, a limp—and the table loved him so much they wrote his daughter into their backstories. He’s the best NPC you never planned. And right now, in front of everyone, you’re about to retcon him into a stranger.

That’s improv at the table. It’s the heart of running D&D—you can prep a dungeon, but you can’t prep the moment a player asks your throwaway shopkeeper what he thinks about the war. So you riff. You invent a name, a grudge, a limp. The table leans in. It’s great.

And then, three sessions later, it quietly falls apart—because the best thing you made, you made on instinct, and nothing was there to catch it.

Here are the improv mistakes that do the most damage—and the one that does the quiet damage no one notices until it’s too late.

Mistake #1: Not writing anything down

This is the big one. The silent campaign-killer—and it’s exactly how you ended up blanking on Garrick.

In the moment, you are certain you’ll remember. The name is obviously Garrick. The daughter ran off with a smuggler. He hates the baron. It’s vivid. It’s burned in.

It is not burned in.

So next session, when the player walks back into the forge, you improvise again—and now the daughter is a son, the grudge is against the church instead of the baron, and Garrick has picked up a completely different accent.

The players notice. They always notice. And now you’re doing an awkward retcon in real time, breaking the fiction to patch a hole you made yourself.

The character stops meaning anything. Not because the idea was bad—because the why got lost. An NPC is only as real as the throughline you can remember.

Mistake #2: Railroading the improv

The opposite failure. You improvise an NPC, but secretly you’ve already decided what they’ll do. The players push, negotiate, get clever—and it doesn’t matter, because the NPC was always going to hand over the quest / refuse the bribe / die in the ambush.

That’s not improv. That’s a cutscene with extra steps. Players can feel the rails under the wheels even when they can’t see them, and it teaches them the worst lesson: their choices don’t move anything.

Mistake #3: Trying to fix mush with “no”

Improv comedy gives us “yes, and”—accept what’s offered, build on it. Most DMs absorb this as gospel. And taken too literally, it curdles.

If the answer to every player request is yes, and here’s more, the world goes soft. No friction, no scarcity, no stakes. The party asks the harbormaster for the fastest ship and gets it. Asks the duke for an army and gets it. Nothing is earned because nothing was ever in doubt.

So DMs reach for the obvious antidote: start saying no. Block the request. Soften it to “no, but” and call it nuance.

That’s the trap. Blocking is the original sin of improv. “No” negates what the player just put on the table—it stalls the momentum and quietly teaches them that offering anything is pointless. And “no, but” is just a block wearing a coat: the player still hears the thing you wanted didn’t happen. You haven’t cured the mush. You’ve traded a world with no stakes for a scene with no air.

Here’s the part everyone misses. The mush was never caused by “yes, and.” It was caused by a toothless and—an “and” that only ever adds gifts. A good “and” adds a complication. You keep saying yes to the player’s reality—their competence, their want, their contribution—and you let the world push back through cost, consequence, and its own agenda.

Yes, the ship exists. And it’s short two crew after a brawl, so passage will cost you sweat, not coin. Nobody got told no. The friction lives entirely in the “and.”

A worked example: “yes, and” with teeth

Here’s the situation. The party needs to leave the city tonight, and there’s exactly one ship sailing before dawn: the Gull’s Mercy. As DM, I want them on that ship—the next chapter happens at sea. But if I just hand it over, the scene is mush. So I never say no. I keep saying yes, and—and I let the “and” do all the work.

Player (Vth, the rogue): We need passage on the Gull’s Mercy. Tonight. Whatever it costs.

DM (as Harbormaster Oluf): He doesn’t look up from his ledger. “Aye, she sails before dawn—and she’s chartered full, grain to the last berth. And Reyes came in two hands short after a brawl at the Drowned Crow last night. She won’t sail undermanned, and she won’t wait.” He finally glances up. “So. Depends what those hands of yours are good for.”

I never told them no. Passage exists—yes. The “and” just keeps stacking the world on top: full ship, and a brawl opened two berths, and those berths are work, not coin. Every clause accepts the scene and tightens it. The players didn’t hit a wall; they got handed a lever.

Player (Vth): We can crew. We’re stronger than we look, and the half-orc could haul cargo all night.

DM (as Oluf): “I believe it.” He taps the ledger. “And Reyes won’t sign strangers on my word alone—last lot I vouched for walked off with the cargo. So you’ll be wanting to give me a reason. There’s a crate going aboard that nobody signed for. Tell me where it ends up, and your names go down as vouched.”

Still no “no.” I yes-and their competence—I believe it—and then the “and” raises the cost and, this is the important part, smuggles in the plot hook (the unsigned crate) as something they’re choosing, not something I’m imposing. No rails. They reached for it.

Player (Vth): Done. We watch your mystery crate, you get us aboard.

DM (as Oluf): He stamps the ledger and slides a chit across the desk. “Yes. And tell Reyes that Oluf says you’re worth your salt—she’ll take it from me. And—since you’re already curious—the man who dropped that crate paid in old crowns. Pre-siege coin. Nobody’s spent those in twenty years. Make of that what you will.”

Once they’ve bought in—paid a cost, made a choice—the “and” pays them back with interest: the vouch, and a thread that deepens the mystery they just signed up for. The scene accelerates instead of going slack.

Same NPC, same goal, three turns, and not a single “no.” The friction never came from refusing the players—it came from the world having its own weight, delivered through the “and.” Nobody got railroaded, nobody got blocked, and the party walked onto exactly the ship I needed them on—thinking it was their idea. Because it was.

The part where it all comes back to memory

Here’s the catch that ties every one of these mistakes together.

That scene only matters if Oluf shows up again. If the unsigned crate pays off. If, ten sessions from now, a player says “old crowns—wait, like the harbormaster mentioned?” and you can actually run with it.

Improv that no one remembers isn’t worldbuilding. It’s a really good campfire story you’ll never tell the same way twice.

You can do everything else right—friction that never blocks, a hook they reached for, zero railroading—and still lose it all to Mistake #1. The complication you built, the thread they took, the name of the NPC who handed it over: gone by next session unless something catches it.

Let Loracle remember the why

This is the gap Loracle fills.

You run the game. You riff, you improvise, you let the “and” carry the friction so the scene never goes soft or slams shut. Loracle records the session, transcribes it, and pulls out the entities—every NPC, the promises they made, the threads they dangled.

So when a player asks Garrick about his daughter, you search and you know: her name, where she went, why he’s angry. No retcon. No “I think it started with a G?”

The improv stays yours. The remembering stops being your job.

Riff fearlessly. We’ll keep the throughline.

They do. They’ve had it for four sessions. They were there when they picked it up.

This is the moment the recap was invented for. Not the wiki, not the binder, not the forty-page campaign bible nobody reads. The two minutes at the top of the night where five distracted adults put down their phones, climb back into people who can cast spells, and remember that last week they swore a blood oath to a goose.

Most tables wing it. “So, uh… where were we?” Someone half-narrates the boss fight. Someone else is sure there was a door. The energy that should be building toward adventure instead drains into a group-therapy session about continuity. By the time you actually start, you’ve spent fifteen minutes and a good chunk of everyone’s enthusiasm just getting back to even.

It doesn’t have to go like that. The recap is a tiny, gorgeous, wildly underrated piece of craft, and once you start treating it like one, your sessions open with a snap instead of a shrug.

So let’s get into it. All of it.

First, throw out the idea that a recap is a summary

A summary is a list of things that happened. You fought the bandits, found a map, went to town, bought rope. Accurate. Thorough. The narrative equivalent of a receipt.

A recap is not a receipt. A recap is an on-ramp. Its job isn’t to inform — it’s to transport. You’re not reminding people what occurred; you’re walking them back to the exact emotional spot they were standing in when you all said goodnight last week. The fear. The grudge. The dumb plan they were one round away from executing.

Get that distinction and everything else falls into place. You stop reading minutes from the meeting and start re-opening a story.

The single best trick: leave the pen down

Here’s a thing Hemingway did, and it’s the most useful recap advice I know even though he never ran a dungeon in his life.

He refused to write a scene all the way to the end. He’d stop while it was still flowing — sometimes mid-sentence — at a point where he knew exactly what came next. Then he’d cap the pen and walk away. The next morning there was no terrifying blank page waiting for him. There was a half-finished sentence with an obvious ending, practically begging to be picked back up.

“The best way is always to stop when you are going good and when you know what will happen next.”

A campaign is the same idea, just stretched over a week instead of a night. End your session on a comma, not a period. Don’t button everything up. Leave a door un-opened, a question un-answered, a sword raised and not yet swung. Stop while it’s still going good.

Then your recap isn’t a chore. It’s you walking back to the page and picking the pen up mid-stroke — and because your players were the ones who helped leave that sentence dangling, they remember precisely where the ink stopped. You don’t have to drag them back into the story. You just finish the sentence, and they’re already inside it.

It’s a beautiful trick. It also has one fatal dependency, which we’ll get to. (Foreshadowing. Leaving the pen down. See what I did there.)

A whole tackle box of recap styles

There is no one right way to do this. There are about fifteen, and the fun is in mixing them. Here’s the menu.

The “Previously, on…” — The classic for a reason. Channel a prestige-TV cold open: three or four punchy beats, present tense, scored by whatever’s dramatic on your playlist. Lead with names. “Kira, your hand is on the vault door. Bram, you’re still bleeding from the thing in the cellar. And nobody has mentioned the letter you all decided not to read.”

Hand the mic to a player. Make recapping a rotating job and pay for it — a point of inspiration to whoever recaps last week. Suddenly someone else is responsible for remembering, they pay closer attention all night to earn it, and you get to learn which moments actually landed (it’s never the ones you’d guess).

Recap in character. This is where it gets delicious:

• The bard’s song. Four lines, badly rhymed, sung off-key. Comedy gold and a genuinely efficient recap.
• The tavern rumor. Two NPCs gossip about “those adventurers” — which lets you recap and foreshadow and slip in misinformation all at once.
• The letter home. A player writes three sentences to their character’s mother. Tells you everything about what mattered to them.
• The villain’s status report. The big bad updates their dark master on the heroes’ annoying progress. Players love hearing themselves described as a threat.

The headline. Recap the session as a newspaper front page. “LOCAL HEROES INSULT DUKE, ADOPT GOOSE, FLEE.” Story on page 4. Whimsical, fast, weirdly memorable.

The open-loops board. Keep a running list — physical index cards are great — of every dangling thread: unkept promises, unanswered mysteries, NPCs who owe the party a favor or a knife in the back. Your recap is just you reading the three or four cards that are about to come due. Players feel the plot tightening.

The cliff. The purest version of leave-the-pen-down: end so abruptly that the recap writes itself, because everyone’s been thinking about it all week anyway.

The map pin. For the visual table — drop a pin on the map, slide the tokens to where they stood, and narrate from there. Spatial memory does half the work for you.

The 80-word straitjacket. Constraint as a feature. Force the whole recap into eighty words and you’re physically incapable of rambling about the rope you bought. Only the load-bearing beats survive.

Mix these. Sing one week, hand off the next, run a villain’s report when the campaign goes dark. Variety keeps the ritual from going stale, and the ritual is the point — same beat every week and your players learn to drop into character the instant it starts.

The boring mechanics that make it sing

Style is the fun part. Logistics are what make it actually happen every week instead of just the weeks you remember to prep.

When. Top of the session, full stop. A recap at the end of last week is a nice idea that nobody’s brain absorbs while packing dice. Do it cold, at the start, when it’s load-bearing.

How long. Ninety seconds to two minutes. If you’re past three you’ve stopped recapping and started re-running. Trust the eighty-word instinct even when you’re speaking off the cuff.

What to cut. Almost everything. The shopping, the travel montage, the long rest — gone. Recap only what tonight’s opening scene actually leans on. A recap is defined by what you leave out.

Where to keep it. Have something — a pinned Discord message, a running doc, the back of a napkin. Not because you’ll read it aloud, but because Tuesday-you needs a place to find out what Saturday-you thought was important. The gap between those two people is where campaigns quietly fall apart.

How it goes wrong (and it goes wrong the same five ways)

• The data dump. Every detail, no shape. Players glaze. You’ve recapped your way out of momentum.
• The DM monologue. Twelve unbroken minutes. Hand the mic out before it becomes a TED talk.
• The wrong altitude. You recap the lore and skip the feelings, or recap the feelings and skip the one fact tonight depends on.
• The confident lie. You misremember the NPC’s name, say it with total authority, and now it’s canon. Your players will remember the wrong name forever, and it’s your fault.
• The skip. “We all remember, let’s just go.” You don’t. You really don’t.

The catch nobody mentions

Here’s the fatal dependency I promised you.

Every technique above — the leave-the-pen-down comma, the open-loops cards, the in-character bard song, all of it — quietly assumes one thing: that you can remember the session well enough to recap it.

And a week is long. Between Saturday’s session and Tuesday’s recap there was work, and sleep, and laundry, and a whole other show you watched, and an argument about something unrelated. The dangling sentence that was so vivid when you packed up the dice is now a blur. Was the captain alive or dead? Did the NPC actually ask that question or did you just mean to have them ask it? What in the nine hells was his name?

You left the pen down on purpose. Then you lost the page.

This is the quiet tragedy of the recap as a craft: the better the unfinished beat, the more it hurts to misremember it — and you will, because you are a person, and people forget. The recap depends on a perfect record of the session, and your memory is the least reliable place to keep one.

So keep it somewhere else.

Where Loracle comes in: from raw transcript to a memory that recaps itself

This is the part we actually built, so let me show you what’s under the hood — because “AI takes notes” undersells it by a mile. The interesting work isn’t the transcription. It’s everything that happens after.

It starts simply. Loracle sits in your Discord voice channel and records the session. When you’re done, it transcribes the whole thing — every name, every aside, every “wait, say that again.” That alone solves the smudge problem: there’s now a perfect record of what was actually said. But a four-hour transcript is its own kind of useless. Nobody reads a wall of text before game night. So the real pipeline begins.

The first pass reads the session like a DM would. It writes your Quick Replay — a tight two-or-three-paragraph recap built for exactly the on-ramp job we’ve been talking about — and even gives the session a punchy episode title. Then it goes looking for things: it pulls out the characters, locations, quests, items, spells, and monsters and files each one under its canonical name with a one-line description drawn from what happened. Your raw audio becomes a cast list.

Then it maps how everyone’s tangled together. A second look extracts relationships — who killed whom, who betrayed whom, who traveled where, who quietly acquired the cursed amulet. Not a list of nouns; a graph of a living world. This is the open-loops board, built for you, automatically.

And then the enrichment passes start — and this is the good part. A single session is just one data point. A campaign is the through-line. So Loracle runs a series of passes across your whole history:

• An entity-merge pass notices that “the captain,” “Captain Voss,” and “that guy from Thornwood” are all the same person, and quietly stitches them into one character — descriptions, relationships, and all — so your cast doesn’t fracture into a hundred half-remembered duplicates.
• A timeline pass synthesizes each entity’s appearances across every session into something that reads like a wiki article. Click Voss and you get his whole arc, not just last Tuesday.
• A relationship pass infers the connections that span sessions — the grudge that started in session three and pays off in session nineteen.
• A consistency pass plays continuity cop: it flags contradictions, orphaned threads, and the duplicate NPCs you didn’t catch. (It’s the friend who says “wait, didn’t he die?”)
• A theme-and-arc pass steps all the way back and watches for the shape of the thing — quest progressions, faction dynamics, the narrative arcs you’re weaving without realizing it.

All of that pours into a World Feed — first appearances, NPC deaths (rip), relationship shifts, campaign milestones — so the story’s evolution is something you can actually scroll. And when you edit something by hand, the system marks it as canonical and the enrichment passes leave it alone. You’re always the DM. It just never forgets.

Here’s what that does for your Tuesday. You leave the pen down on Saturday — a comma, a raised sword, a question left hanging — and you walk away without a shred of anxiety about losing the page. Because the page is kept. Three days later the Quick Replay is sitting there waiting, the captain’s name spelled right, the open loops listed, the exact unfinished sentence ready to pick back up. You read it, you feel the session click back into place, and you start the night on a snap.

Your players climb back into people who can cast spells. The rogue, you can now confirm, still has the amulet. And the goose oath remains, as ever, fully canon.

“Wait — that’s the guy from Thornwood. We were supposed to bring his son back.”

You stare at her. You glance at your notes. The name you just said is not the name on the page. She is right. You are wrong.

This used to mortify you. After enough campaigns, it stops.

The myth

There’s a fiction at the heart of how DMs talk about the craft. The DM is the keeper of the world. You arrive at the table with the canon — notebook, binder, wiki, whatever — and the players show up empty-handed to be told things.

It has never been true.

In a campaign long enough to matter, your players hold as much of the world as you do. More, usually. They remember the NPC you invented at eleven PM and forgot by Tuesday. They quote dialogue you have no memory of writing. They argue about what really happened in session nineteen, and you nod along, because you don’t know who’s right and it would be impolite to admit it.

You’ve been running on borrowed memory for months. You just haven’t said so out loud.

What it really is

Here’s the part that took me a long time to see: this is fine.

The instinct is shame — that you should have written it all down, that you’ve failed your players. But the campaign was never a thing you held in your head and dispensed. It was a thing you all made, in the room, together. They kept their parts. You kept yours. The whole only existed when you sat down at the table.

Your players have always been the memory.

They just had no way to look at it without you.

The campaign lives in a dozen places — your prep, their notes, the scene Mike still talks about, the offhand line that became Sarah’s character’s whole arc. You’re the one with the binder, so you’ve been treated like the one with the truth. But the truth was distributed all along. Your binder is just the bit you wrote down.

What we shipped

A read-only link you can send to your players. They open it — no account, no app — and there’s the world. The characters they’ve met. The places they’ve been. The threads, sourced to the sessions where they happened.

A note on what this is. It’s not a database for your players to study so they can quiz you. It’s not a “player engagement tool.” Most players do not want homework, and a campaign that demands homework is asking the wrong thing.

It’s an acknowledgment.

For years your players have been doing the memory work — keeping notes you couldn’t, remembering scenes you forgot. The share link makes that work visible. It says: this campaign isn’t a story I’m telling you. It’s a story we’re keeping. You should be able to see what we have.

The room you’re already in

Some of your players will browse it. Most won’t. That’s fine. The point isn’t that everyone reads the wiki — the point is that the wiki is theirs. The world that exists between you isn’t locked in a DM’s binder anymore. It can be looked at. By the people who helped build it.

What changes when you send the link isn’t really their experience. It’s yours.

You stop pretending to be the source. You stop carrying the campaign like a secret you have to dispense correctly. You stop the small, exhausting performance of always knowing — because the binder is open, and what’s in it is what’s in it, and what isn’t is something you’ll figure out together, the way you always have.

You’re not the keeper of the world. You’re the one with the dice.

The world belongs to the room.

I don’t know what it was. I don’t know who it was to. I don’t know when they’ll call it in. But I know it’s there—buried somewhere in the hundred-plus hours we’ve spent at the table together, waiting.

Maybe it was something an NPC said in the heat of the moment. Maybe it was a throwaway line that landed harder than I expected. Maybe it was a deal struck in a tavern, a vow made in a dungeon, a whispered secret that meant nothing to me and everything to them.

They remember. I don’t.

And someday, they’re going to look at me expectantly, waiting for me to deliver on something I have no memory of promising.

This is the fear that lives in the back of every Dungeon Master’s mind.

The weight of a living world

When you run a tabletop campaign, you’re not writing a novel. You’re not directing a film. You’re doing something much stranger: you’re improvising a story in real-time with a group of people who have their own ideas, their own agendas, their own memories of what you’ve said.

Every session, you speak thousands of words. You invent characters on the spot. You describe locations you’ve never seen before. You make rulings, drop hints, plant seeds. You respond to questions you didn’t anticipate with answers you won’t remember giving.

And all of it matters. Not to you—not in the moment—but to them. To your players, who are building a mental model of your world based on every word you say. Who are forming attachments to NPCs you invented to fill thirty seconds of dialogue. Who are theorizing about prophecies you ad-libbed at midnight when your brain was running on fumes.

A novelist can revise. A screenwriter can edit. You can’t. The words leave your mouth and become canon instantly, irrevocably. Your players heard them. They wrote them down. They’re going to hold you to them.

The world you’re building isn’t in your notes. It’s in the air between you and your players. It’s in the session itself—the living, breathing, ephemeral thing that disappears the moment you pack up the dice.

Your notes are what you planned. The session is what happened. And they’re never the same.

The slow forgetting

I’ve been running games for over a decade. I’ve tried everything.

I’ve kept detailed session logs—twenty pages of notes that I never read again because who has time to reread twenty pages before every session. I’ve used wikis, databases, Obsidian vaults with hundreds of linked entries. I’ve bought fancy notebooks with index tabs and color-coded sections. I’ve delegated note-taking to players. I’ve recorded sessions and told myself I’d listen back later.

I never listened back. Nobody listens back. Four hours of audio to find a single detail? The economics don’t work.

And still, the forgetting happens. It always happens.

Not the big things. I remember the big things—the dragon fight, the character death, the twist that made everyone gasp. Those moments burn themselves into memory. They become the stories we tell about our campaigns years later.

It’s the small things that slip away. The name of the innkeeper in the town they loved. The exact wording of the curse. The backstory detail a player mentioned once that I promised would come back. The half-formed plot thread I dangled and then lost in the chaos of everything else.

The small things are where the magic lives. The small things are what make a campaign feel real—like a world that exists beyond the edges of the spotlight, full of people and places and consequences that persist whether you’re looking at them or not.

When you forget the small things, the world gets thinner. The NPCs become interchangeable. The locations blur together. The sense that actions have consequences starts to fade, because consequences require memory, and memory is failing.

I was losing them. Constantly. Silently. One forgotten detail at a time.

The breaking point

The moment I knew something had to change came about two years into a campaign.

We were deep into the story—past the point where you can easily retcon, past the point where the players have built complex mental models of how everything connects. This was a campaign where the players had notebooks of their own. Where they tracked NPCs and relationships and debts. Where they cared about continuity because I’d taught them to care.

One of my players—let’s call her Sarah—asked about an NPC. Someone they’d met early on, someone who’d given them a warning about something. She wanted to know if the warning had come true. She wanted to know if they should have listened.

I had no idea who she was talking about.

I didn’t recognize the name. I didn’t remember the scene. I couldn’t even fake it, because Sarah was asking specific questions about specific things this character had supposedly said. She had notes. She had quotes.

I had nothing.

I had to admit it. “I don’t remember.”

The table went quiet. Not angry—my players are kind—but something shifted. I could see it in their faces. The spell broke, just a little. The world stopped being a place that existed and started being a thing I was making up. The difference matters more than I can express.

That night, after everyone left, I sat with my notes. Hundreds of pages. Cross-referenced. Color-coded. The kind of prep that looks impressive on /r/DMAcademy. And I couldn’t find Sarah’s NPC anywhere.

Because I’d never written them down. Because they were improvised. Because the thing my player remembered most vividly from months of play was the thing I’d put the least thought into.

Here’s what haunts me: I still don’t know what I said. I don’t know what I promised. Sarah’s character made decisions based on that NPC’s warning. The whole party did. And I have no idea what warning they were responding to.

I improvised my way through the next few sessions. Made up something that could have been the prophecy. It probably wasn’t what I originally said, but it was close enough that nobody called me on it. The campaign survived.

But I knew: I got lucky. And I couldn’t keep getting lucky forever.

The tools that almost worked

After that night, I became obsessed with solving this problem.

I tried everything on the market. I gave each tool a real chance—months of use, honest effort, genuine hope that this would be the one.

Obsidian was beautiful. I built an elaborate vault with templates and tags and linked references. The graph view made me feel like a genius. But the vault only contained what I put into it, and I kept putting things in wrong. I’d write “the blacksmith” when the players remembered “Garrett the blacksmith,” and suddenly my search was useless. The tool was only as good as my exhausted post-session memory.

World Anvil was comprehensive. Every field you could want, every relationship you could track. But it was built for worldbuilding, not for capturing play. It was magnificent for describing the city I’d prepped. It had nothing to say about what happened when the players burned it down.

Notion was flexible. I could build anything. So I built systems, and then I built better systems, and then I rebuilt everything from scratch because the old system wasn’t working. I spent more time maintaining my Notion than running my campaign. The tool had become the game, and I wasn’t even having fun.

Recording seemed like the obvious answer. Just capture everything, right? I bought a good microphone. I recorded every session. And then I had hundreds of hours of audio that I never once listened to. The information was there—technically—but it was locked inside a format that made it impossible to access. Finding a specific detail meant listening to hours of crosstalk and combat and jokes. Nobody does that.

The pattern became clear: every tool either required me to do the work (and I was the bottleneck) or captured the wrong thing (prep instead of play) or captured the right thing in an unusable format (raw audio).

I needed something that captured what actually happened at the table and made it searchable without requiring any work from me.

Nothing like that existed.

So I started building it.

The gap

Before I talk about building Loracle, I need to explain the problem more precisely. Because once you see it, you can’t unsee it.

Your prep and your play are two different things.

Your notes describe the world you imagine. Your sessions create the world your players experience. And there’s a gap between them—a gap that grows wider every time you improvise, every time you say something unplanned, every time the story goes somewhere you didn’t expect.

In a typical session, maybe 30% of what happens is prepped. The rest is improvised. Riffed. Made up on the spot. And that 70% is usually the best stuff—the moments of genuine surprise, the characters who emerge from nothing, the plot twists you discover alongside your players.

But prep gets preserved. Improv gets forgotten.

Your notes remember the dungeon you designed. They don’t remember what the players actually did in it. Your wiki has the NPC backstory you wrote. It doesn’t have the conversation that made your players fall in love with them.

Most tools are designed for prep. They’re canvases for worldbuilding. They’re where you paint the dungeon before the players kick down the door.

But what happens after they kick down the door? What happens when they ignore your dungeon entirely and befriend the monster outside? What happens when the throwaway shopkeeper becomes the most beloved NPC in the campaign?

That’s the gap. The prep-play gap. And nothing fills it.

You can try to fill it yourself. You can take notes during the session (and split your attention from the game). You can write summaries after (and trust your exhausted memory to be accurate). You can ask your players to help (and hope they caught the things you missed).

But you’re always playing catch-up. You’re always reconstructing. You’re always working from incomplete information about your own world.

The gap isn’t a personal failing. It’s structural. It’s built into the nature of tabletop gaming—a medium where the canonical version of the story exists only in the live performance, and nowhere else.

Until now.

Building the camera

I started working on Loracle because I wanted to solve this problem for myself.

The idea was simple, even if the execution wasn’t: what if you could record your sessions and have AI extract everything that mattered? Not a transcript—nobody wants to read a transcript. But a structured knowledge base: every character mentioned, every location described, every item found, every quest given. Searchable. Browsable. Connected.

Not what you planned. What happened.

I thought of it as the difference between a canvas and a camera. Your notebook is your canvas—where you paint the world before the session. Loracle is your camera—capturing the world as it actually unfolds at the table.

The first version was embarrassingly simple. Speech-to-text, then a prompt asking GPT to “find all the characters.” It worked about 40% of the time. But that 40% was enough to prove the concept. I found NPCs I’d forgotten. I found plot threads I’d dropped. I found details I had no memory of inventing.

The second version got serious about extraction. Not just characters, but locations, items, quests, monsters—the full taxonomy of things that matter in a TTRPG. Context for each one: when did it appear, what was said about it, how does it connect to everything else.

I learned that extraction is harder than it sounds. The AI would find “the door” and catalog it as a location. It would split “King Marcus” and “the king” into two different characters. It would miss the prophecy entirely because it was phrased as a question. Every edge case required thought.

The third version added search. Not just browsing entities, but asking questions. “What did the oracle say about the sword?” “Who betrayed us in Waterdeep?” “What did I promise the dragon?” The AI finds the relevant transcript sections, synthesizes an answer, shows its sources.

This is where it started feeling like magic. Asking a question about my own campaign and getting an accurate, sourced answer in seconds—it felt like having a research assistant who’d attended every session and taken perfect notes.

The fourth version is what you can use today. It’s not perfect—nothing is ever perfect—but it works. It closes the gap. It makes sure the improvised details are as preserved as the planned ones. It gives you a memory that doesn’t forget.

What you actually get

Let me be concrete about what this means in practice.

You get instant recall. Someone mentions an NPC from twenty sessions ago. Instead of frantically flipping through notes, you search. “Who is Mira?” Three seconds later: “Mira is a halfling merchant the party met in Thornwood. She sold them the enchanted compass and warned them about the Baron’s spies. First appeared in Session 7.”

You get the exact words. Not what you think you said. Not what you vaguely remember. The actual transcript. “What did the prophecy say?” Here it is, verbatim, with the timestamp if you want to listen.

You get connections you didn’t notice. The AI sees patterns across sessions. “Mira mentioned the Baron. The Baron was connected to the Thornwood conspiracy. The conspiracy involved the artifact the party found in Session 12.” Your improvised details start weaving themselves into coherent threads.

You get player recaps without the work. Every session generates a summary. Your players can read what happened last time without you having to write it. Show up to the table ready to play instead of spending 20 minutes recapping.

You get freedom to improvise. This is the big one. When you know the details are being captured, you can stop trying to capture them yourself. You can stop the anxious mental note-taking. You can be fully present in the scene, knowing that whatever you invent will be there when you need it.

The best sessions are the ones you couldn’t have prepped for. Loracle makes sure those sessions aren’t lost.

What you discover about yourself

There’s something I didn’t expect.

When you can search your own campaign, you start seeing patterns. Connections you didn’t notice. Threads you didn’t realize you were weaving. The unconscious storytelling that happens when you improvise over dozens of sessions starts to become visible.

I found foreshadowing I didn’t know I planted. I mentioned a burned village in session 3 that became central to the plot in session 30. I didn’t plan that. I didn’t even remember mentioning it. But there it was, waiting.

I found character arcs I didn’t know I was building. An NPC I’d introduced as comic relief had slowly become more serious, more burdened, more complex. The progression was invisible session-to-session, but obvious when I could see the whole history at once.

The campaign becomes legible in a way it never was before—not just to your players, but to you.

You start to understand your own instincts. You notice the themes you return to, the character types you gravitate toward, the story structures that emerge naturally from your improvisations. The campaign becomes a mirror.

You become a better DM. Not because you’re working harder, but because you can see your own work clearly for the first time.

For the players, too

I built Loracle for DMs, but I’ve learned it might matter even more for players.

Think about what it’s like to be a player in a long campaign. You show up every week or two. You try to remember where you left off. You have a vague sense of the major plot points, but the details blur together. You’re dependent on the DM to remind you what’s happening—and the DM is barely holding it together themselves.

You want to engage with the lore, but you can’t remember it. You want to reference past events, but you’re not sure you have them right. You want to roleplay continuity, but you’re faking half of it.

Now imagine being able to search the campaign yourself. “Who was that dwarf we met in the mines?” “What did my character promise the witch?” “What did the letter actually say?”

No more waiting for the DM to find their notes. No more “I think it was something like…” No more faking it when you can’t remember.

Players get to engage with the world the way the DM does—with full access to what’s happened, full ability to connect the dots, full ownership of the story they’re helping to tell.

The campaign stops being something the DM manages and the players consume. It becomes something everyone can explore together.

Built with care

A word about how we approach this. Because I know what you’re thinking.

Your campaign is personal. The stories you tell at the table are intimate—full of inside jokes, vulnerable moments, creative risks, things you’d never want a stranger to hear. The idea of feeding that into an AI system should give you pause.

It gives us pause.

We’ve built Loracle with that discomfort in mind.

Your recordings stay yours. They’re stored securely so you can re-listen to any session—scrub through the audio, hear exactly how that conversation went down, relive the moment your player rolled a natural 20 at the worst possible time. The audio isn’t just processed and thrown away; it’s part of your campaign archive.

Your data is yours. We don’t use your campaigns to train our models. We don’t share your information with third parties. We don’t mine your sessions for insights about “what gamers want.” Your campaign stays private, period.

We’re also careful about what the AI does and doesn’t do.

Loracle extracts and organizes. It doesn’t invent. It doesn’t generate content. It doesn’t decide what your world should be or suggest what should happen next. It doesn’t write your NPCs or plot your campaigns or create content on your behalf.

We’ve seen the AI tools that do that. They’re impressive. They’re also not what we’re building.

Loracle is a memory tool, not a creativity tool. The goal is to augment your memory, not replace your imagination. The story is still yours—your voice, your choices, your improvisations. Loracle just makes sure you don’t lose them.

The promise we’re keeping

Somewhere in your campaign is a promise you made and forgot.

Maybe it’s a prophecy you invented at midnight when you were tired and reaching. Maybe it’s a deal you struck with a player who was more invested than you realized. Maybe it’s a detail that seemed small at the time but meant everything to someone at your table.

That promise is waiting. Your players remember it, even if you don’t. And someday—maybe next session, maybe next year—they’re going to expect you to deliver.

Loracle is how you find it before they ask. How you discover the threads you’ve been weaving without knowing it. How you close the gap between what you planned and what happened.

It’s not a replacement for good notes or careful prep or the hard work of running a great campaign. It’s a safety net. A backup brain. A guarantee that the small magic—the improvised details, the offhand remarks, the tiny promises—won’t slip through the cracks.

It’s the campaign memory you don’t have to build.

Record your sessions. We’ll remember them for you.

And when your players finally ask about that prophecy, that NPC, that promise you made and forgot—you’ll have an answer.

Loracle is available now. Try it free and never ask “what happened last session?” again.

Maybe it’s Obsidian with a sprawling vault of linked notes. Maybe it’s Notion with databases for NPCs, locations, and quests. Maybe it’s World Anvil, or a physical notebook with color-coded tabs, or a Google Doc that’s gotten out of control.

You care about your campaign. You put in the work. You take notes.

This post is for you.

The gap between prep and play

Your system captures what you build. The worldbuilding. The NPC backstories. The dungeon maps and faction politics. That’s your canvas—where you paint the world before the session.

But what happens during the session?

Players ask unexpected questions. You invent answers. A shopkeeper gets a name, a personality, a secret. A location gets described in ways you never wrote down. Relationships form. Promises are made. Plot threads spawn from throwaway lines.

Some of this makes it into your notes. After the session, if you remember, if you have time.

Most of it doesn’t.

The 80% problem

Here’s a rough estimate: you probably capture 20% of what happens at the table.

The other 80%—the improv, the details, the emergent story—lives only in memory. And memory is unreliable. It fades. It distorts. It conflates session 15 with session 22.

Your notebook is full of what you planned. It’s missing what happened.

A camera for the table

Loracle isn’t trying to replace your notebook. We’re not another place to take notes.

We’re the camera.

Record your session. We transcribe it, extract the entities—every character, location, item, and quest mentioned. Then we make it searchable.

Your notebook stays your notebook. Your system stays your system. But now you have a source of truth for what actually happened at the table.

When you’re updating your Obsidian vault after a session, you don’t have to rely on memory. Search Loracle: “What did we name the blacksmith?” “What was the prophecy wording?” “Who did the rogue promise to help?”

Sourced answers. Copy them into your notes. Your canvas gets richer.

The workflow

Here’s how it fits:

1. Before session: Prep in your tool of choice. Build the world.
2. During session: Focus on running the game. Loracle records.
3. After session: Search Loracle for what happened. Update your notes with real information, not guesses.

No new system to learn. No migration. Just a layer that catches what you’d otherwise lose.

For the note-takers

You’re already doing the hard work. You care enough to build systems, to organize, to remember.

Loracle just makes sure your system has access to everything—not just what you prepped, but what emerged. Not just your plans, but your play.

Your notebook is your canvas.

Let Loracle be your camera.

I’ll bet you anything: it wasn’t the one they prepped the most.

It was the one where everything went sideways. Where the players ignored the dungeon and befriended the monster. Where an NPC invented in desperation became the campaign’s heart. Where the story went somewhere no one—including the DM—expected.

The best sessions emerge. They can’t be planned.

The improv paradox

Here’s the tension every DM lives with:

You prep because you care. You build the world, design the encounters, write the dialogue. That’s craft.

But the magic? That happens when you throw it away. When you riff. When the players surprise you and you surprise yourself.

The barbarian adopts the goblin. The wizard makes a deal with the wrong god. The party decides to open a tavern instead of saving the kingdom.

And you roll with it. You invent. You discover the story alongside your players.

These moments are gold. They’re also the first thing forgotten.

The memory gap

Prepped content survives. It’s in your notes. The dungeon map, the NPC backstory, the plot outline—you wrote it down before the session.

But the improv? The stuff that actually made the session great?

That exists only in the moment. In the memory of everyone at the table. And memory fades.

Three sessions later, someone asks: “What was the name of that goblin the barbarian adopted?”

Silence. Nervous laughter. “I think it started with a G?”

The magic is gone.

Catching lightning

This is what Loracle is for.

Not to replace your prep. Not to generate your story. But to catch the lightning.

Record the session. Let us listen. We’ll find:

• The NPC name you invented at 11 PM when your brain was fried
• The promise made in the heat of roleplay
• The plot twist that emerged from a joke
• The lore you improvised and immediately forgot

All searchable. All sourced. All yours.

So next time someone asks about the goblin, you don’t guess. You know. And you can build on it—because nothing was lost.

Keep riffing

The best DMs aren’t the ones who prep the most. They’re the ones who can let go—who trust the improv, who play to find out what happens.

Loracle lets you do that without fear.

Riff harder. Go off-script. Let the story emerge.

We’ll remember it for you.

Session logs. NPC lists. Relationship maps. Plot thread trackers. The advice is everywhere—buy a nice notebook, develop a system, write everything down.

And it makes sense. When you’re running a campaign that spans months or years, memory fails. Players ask about the shopkeeper from session 12. They want to know what the prophecy actually said. They remember making a deal with someone, but not who.

So you write it all down. Or you try to.

The problem with notes

Here’s what actually happens:

1. You run an incredible session. The players go off-script. An NPC you invented on the spot becomes their favorite character. Someone makes a promise that will matter later.

2. The session ends. Everyone’s tired but happy. You clean up, maybe have a drink, decompress.

3. You think: “I should write this down.”

4. You don’t. Or you write half of it. Or you write it but forget the important part.

5. Three sessions later: “Wait, what was that guy’s name?”

The notes you take are filtered through exhaustion, through what you thought was important, through the limits of memory. They’re incomplete by definition.

Your notes are what you remembered to write. Not what happened.

A different philosophy

What if the expectation is wrong?

What if you shouldn’t have to take notes?

Your brain is for storytelling—for voices, for drama, for thinking on your feet when the players do something unexpected. That’s the hard part. That’s the art.

Why should you also be the stenographer?

The camera, not the canvas

Think about it this way: you’re creating something at the table. A living, improvised story. Your notebook is your canvas—where you build your world, prep your encounters, sketch your ideas.

But the session itself? That’s a live performance. And live performances need a camera, not a canvas.

Something that captures what actually happened. The NPC name you invented. The promise the rogue made. The plot twist that emerged from chaos.

Not what you planned. What happened.

Loracle’s bet

This is why we built Loracle.

Record your session. We’ll transcribe it, extract the characters, locations, quests, and items. We’ll remember what you forgot to write down.

Then, when you need it: ask. “What did the oracle say about the sword?” “Who was that merchant in Waterdeep?” “What did we promise the dragon?”

Sourced answers. In seconds.

Your brain stays free. For the next voice. The next twist. The next moment of magic at the table.

Because you shouldn’t have to take notes.