Does the AI game master cheat, and is its writing actually any good?

The first two comments under every ad we run are always the same: "If the AI rolls the dice, it'll just write whatever number it feels like," and "AI English is stiff and generic — I'll spot it within two paragraphs." Both are healthy reflexes. Both are really two sides of one sentence: in this game the AI does not roll the dice, and it cannot override the rules; it only narrates. This page doesn't argue that sentence, it shows it — with unedited turn output, with one line of code, with numbers that live on the server. And while showing it, it doesn't hide the flaws: the places the prose still stumbles and the places the model is still wrong are written down on the same page, in the same detail.

Short answer (30 seconds)#

• The AI doesn't roll: the server generates the number with random_int, you throw the 3D die, and the model only narrates.
• The rules live outside the model: the bonus ceiling, the boss damage caps and the levelling rules are in server code, not in the prompt.
• A boss death the numbers don't support is refused before you ever see it, and the turn is rewritten.
• The narration isn't translated: it's generated directly in English — and we list its flaws one by one below.

Why this page exists#

This page was written by Thavernia's founder, Furkan Aydemir. These are the first two questions the ads attract, and both are fair; neither can be answered with a marketing sentence, because both are technical claims. The rule for this page: every claim here comes with either a screenshot, a line of code, a number that sits on the server, or a "try it yourself like this" instruction. We didn't write anything we can't prove; we also didn't delete the things we can prove that make us look bad. The three free turns at the end exist for exactly this reason: so you can test the claims yourself.

Doubt 1: "AI prose reads like a machine wrote it"#

Let's grant the objection first, because the answer is meaningless without it. This reflex was earned the hard way. We've all read AI text that arrives with the same tells: a paragraph that opens on a sweeping abstraction, three adjectives where one would do, everything described as "a testament to" something, a rhythm so even it stops meaning anything. People have learned to detect it without a detector — by cadence alone.

The prejudice is earned

And it isn't only a feeling; it's a documented fight. Fan translators and localisation professionals have spent the last few years watching machine output shipped under a "localised" label, and forums in every language have long threads about it. Publishers who experimented with AI-assisted translation ran into the same backlash from their own readers. The recurring line in those threads is the one that matters here: machine prose is recognisable from its rhythm, before anyone checks a single fact.

The reason it's recognisable is structural. Machine-shaped English keeps the scaffolding visible: a subject-first sentence, clauses stacked in the same order every time, hedges nobody needed, idioms flattened into their literal meaning, and that unmistakable corporate register — "it is important to note," "a rich tapestry of." A reader knows where the sentence is going before it gets there; the text feels assembled rather than written. In a roleplaying game that's fatal, because the only thing holding the game up is that you believe the text.

Credit where it's due: if you want to play in English, you have plenty of options, and some of them are far older than us with much wider worlds. The problem is what happens on the way out of the generic register, and what happens to every other language when a system built in English is opened up to it — the interface gets localised and the narration goes through a translation stage, and the same smell comes out the other end. The long form of that comparison is on the alternative to AI Dungeon page.

An unedited turn, exactly as it appeared

However loudly a page insists "our prose is good," the only honest evidence is unedited output. The two blocks below are taken from real campaigns; the caption carries the campaign name and the date, and not one word was corrected. One is a quiet scene description, the other a combat turn with the dice results and damage badges visible. If there's a clumsy sentence inside, it's still there and we've written underneath why it's clumsy; polishing them would have emptied this page of its point.

Read for these four things: whether names and proper nouns are handled with any texture or just repeated, how often a filler intensifier shows up ("suddenly," "slowly," "seemingly"), whether sentence lengths vary or all land at the same width, and how characters address one another. Those are the four places machine prose gives itself away fastest.

What machine-shaped prose looks like — side by side

The fastest way to show the difference is to generate the same scene twice. On the left: a scene written in the flat, register-safe style a system produces when nobody is fighting for voice — not a deliberately bad sample, an honest one, and the same thing many setups ship today. On the right: Thavernia's output. The campaign's narration language is chosen on the creation screen and is separate from the interface language; the model writes in that language directly, with no translation step in between. The same holds for en, tr, de, it, fr and es.

The difference shows up in three places. Rhythm: the flat pipeline builds long, padded sentences of uniform length; direct generation lets a short sentence stay short. Idiom: the flat pipeline reaches for the safest phrasing available; direct generation picks the image the scene actually calls for. Address: the flat pipeline keeps a polite narrator's distance from everyone; direct generation lets a mercenary talk like a mercenary and a magistrate talk like a magistrate. Each of these looks small alone, but stacked together they are precisely what produces the feeling that a text was manufactured.

Where the language strains the machine, and what we did

Every language has spots where a model works harder, and the most concrete one for a game is invented proper nouns. The model coins a town, then has to keep it stable: the same settlement can't be Halloway on one turn and Hallowway on the next, and the possessive of a name ending in -s has to hold across twenty turns. There's a world-state side to this too: when the same NPC appears as "Kadran" in one turn and "the warden of Kadran" in the next, we key them through a matching function that strips titles and grammatical decoration so the ledger doesn't quietly invent two separate people.

The second trap is case conversion, and we learned it by shooting ourselves in the foot. We had an English heading in the interface upper-cased through CSS; because the page's declared language was Turkish, the browser turned "i" into "İ" and a strange hybrid appeared on screen. The rule is now explicit: we don't CSS-upper-case English text on a page declared in another language. The same care is needed inside the text, because any comparison that folds case can silently return the wrong answer once a locale is involved.

Third, the structural lines the game master emits each turn — enemy HP, quest step, item gained. The model sometimes writes those labels in the campaign's narration language rather than the canonical form. We normalise them to a single shape before anything is recorded; otherwise a line labelled in the local language would silently drop and the item would never appear in your inventory.

Where the prose still stumbles

The honest list. All of these can still happen today; we're not marking any of them "solved."

• Recycled imagery. In long campaigns the same picture comes back around — the smell in the air, the guttering torch. The prompt forbids repetition, but after twenty turns it still shows. This is the flaw we get the most complaints about.
• Register drift. Occasionally an NPC slides into a stiffer, more formal voice for no reason. Tone is tuned per campaign, but some still slip through.
• Truncated sentences. On very long turns the text can be cut off at the end. We added a trimming guard for that: an unfinished final sentence is discarded rather than shown. So you don't see broken text, but that turn ends one sentence short.
• Awkward possessives on invented names. Coined names — especially ones with unusual sound shapes — sometimes take a possessive or plural that reads wrong. The meaning survives; the ear notices.
• The occasional stock phrase. Rarely, a piece of generic AI-register filler slips into a sentence. Every instance we catch gets added to the prompt as a banned phrase.

Doubt 2: "The AI lets you win — there's no real risk"#

There is a case where this doubt is technically completely correct, so let's describe that first. If a language model writes its own dice roll, that number is not random. A model doesn't generate randomness; it imitates a probability distribution while choosing the next token, and it listens to context. If the context says "the hero is at the door, the tension is peaking," the number comes out accordingly. That's why 17s and 18s show up with odd frequency in chatbot games, and why things always seem to work out at the critical moment.

So the objection stands: if the dice are in the model's hands, what you're playing isn't a game, it's co-writing — a lovely thing, but with no risk of losing inside it. The detailed breakdown is on the playing D&D with ChatGPT page. Thavernia's single architectural claim starts exactly here: take the number out of the model's hands.

The dice aren't the AI's: two-phase rolling

The flow works step by step like this:

• You write what you want to do.
• The game master decides which ability is tested and how hard it is: "Agility check, difficulty 14."
• The difficulty is written to the server. From that moment it's closed to the model: it can't be raised or lowered afterwards.
• The server generates the d20 right there and writes it to the database — before you throw, before the model sees a result.
• You throw the 3D d20 on screen; the animation lands on that recorded number. Other players at the table see the same die, in the thrower's dice skin.
• The result plus your bonus is compared against the difficulty; success or failure is decided on the server. The model only sees this once it's settled, and only narrates it.

All of a turn's dice open at once and are thrown in sequence. Abandoning the turn to force a reroll doesn't help either: when a new turn opens, pending dice are cleared and the old result doesn't come back. What your bonus is and which equipment counted is printed on the dice screen — and the narration only uses gear you've actually equipped; a sword sitting in your pack can't be narrated as though it's in your hand.

Where the number comes from: one line of code

The cheapest and most convincing piece of evidence is a single line: $d20 = random_int(1, 20);. random_int is PHP's cryptographically secure random number generator; it's fed from the operating system's entropy source and designed not to be predictable. That line runs on the game server, not in your browser; the browser's only job is to animate that number on the die. The same line sits both where the roll is decided in advance (gm/plan.php) and where the roll is submitted (dice/submit.php).

Natural 20 and natural 1 are also independent of difficulty: a 20 succeeds under any circumstances, a 1 fails under any circumstances, and the model can't reverse either — it can only narrate it more gloriously or more painfully. The honest limit: someone on the outside can't directly verify which code is running on our server. What you can do is probe the behaviour — roll a lot, and see whether low rolls genuinely burn you. That's the first place a rigged system cracks.

The rules the AI can't override

Dice alone aren't enough: a model can accept the roll and then bend the rules. So the numeric side of the game lives in server code, not in the prompt. Everything below is a rule — a number — and what it prevents:

• Ability bonus ceiling — the classic +5 up to score 20, then +1 per 4 points, hard ceiling +7 at score 30. Stops you inflating a single stat until the d20 stops mattering.
• Boss threshold — an enemy above a 120 base-HP threshold counts as a boss. Takes the "is this a boss" decision out of the model's hands.
• Single-blow cap — roughly 10% of maximum HP, floor 15. Stops "I take its head off" from ending the fight in one move.
• Natural 20 cap — about 20%, floor 25. Keeps a critical hit spectacular without turning it into a one-shot.
• Three phases — a boss fights across three HP phases. Stops a set-piece battle from closing inside one turn.
• The miss rule — if the party rolled attacks and all of them missed, the boss takes zero damage that turn; turns with no dice at all (a trap, a collapsing gallery) still allow one blow's worth. Stops a boss being ground down through pure misses.
• The background repair can't lower a boss's HP — the correction layer that runs after a turn can't route around the cap and kill a boss by increments.
• Friendly fire and the party rule — the party can wound each other, but a party member can never be written into the enemy row. Closes the exploit of killing your own companion for experience.

What happens when the AI says "the boss is dead"

This is the most striking piece of evidence, because this is where the machine's fiction gets caught. The model sometimes narrates a boss death the numbers don't support: it topples a giant sitting at 90 HP with a single blow, because the scene wants it. Before showing you that turn, the server checks: given this boss's remaining HP, could the party's successful attacks this turn actually bring it to zero?

The check is deliberately generous — every successful hit is counted as a critical — so that a legitimate finishing blow isn't refused by mistake. If the arithmetic doesn't work, the turn is rejected and the model rewrites it with the real numbers: the blows wound the boss, the boss stays standing and hits back, the fight continues. The rest of the turn's events are preserved. Every rejected turn is logged, so we don't estimate how often this happens — we count it.

So can you actually lose?

Yes, and this question deserves an answer with no slack in it. Characters die. Friendly fire is real: a spell that goes wide takes a party member's health with it. NPCs have HP, friendly ones included, and they can be killed and don't come back. Levelling and experience follow D&D strictly: ability score improvements arrive every four levels, stat growth has a ceiling, and no free experience trickles in — XP comes only from what you actually do. This system isn't built to hand you more; it's built so losses mean something. What still slips past all of that is the subject of the next section.

Where the AI is still wrong (and what gets caught)#

The second half of the honesty lives on the world-state side. Each turn the model produces structural lines alongside the story: a new NPC was met, a quest advanced a step, an item entered your pack. Sometimes it drops those lines — in the story you picked up the sword, in the ledger you didn't. This happens with every model that produces long narration.

For that there's a correction layer that runs in the background after the turn: it re-reads the text, re-extracts the dropped lines and applies them. The operation is idempotent — the same line isn't applied twice, and two swords don't appear in your inventory. Its authority is limited too: it can't lower a boss's HP, because the live turn already applied the wound and seated it against the cap, and we don't want that cap leaking under the name of "recovery."

What still gets missed? Sometimes an item shows up a turn late. Sometimes you have to remind the game master explicitly to advance a quest step. Rarely, an NPC's mood doesn't land in the record as sharply as it read in the narration. All of it is written to drop telemetry; we see which type drops how often and tighten the prompt accordingly. We're not claiming perfection — we're measuring.

"Is Thavernia trustworthy?" — money, cancellation, data#

This question isn't about game mechanics, it's about commercial trust, so the answer should sit on one screen:

• Who runs it: Loopcode Bilişim Yazılım Mühendislik Eğitim ve Danışmanlık A.Ş., Türkiye. Contact: info@loopcode.co. Governing law for disputes is Turkish law.
• Payment: taken through the payment provider iyzico. Your card details are processed by the provider and are not stored on our servers.
• Subscription and cancellation: it renews monthly, you can cancel whenever you like, and your access continues to the end of the current period. Gift codes are not refundable or transferable once redeemed.
• No card to try it: the trial opens without an account; the payment step only appears if you ask for it.
• Data: what we keep and why is written on the Privacy Policy and Terms of Use pages. If something isn't answered there, write to the address above.

Audit the evidence yourself: 3 turns, no card#

Everything you've read up to here is testable. The trial asks for no account and no card, and gives you three turns — and those three turns are three turns in total, not three a day. Three turns won't finish a campaign; they're more than enough to probe the claims. Try these:

• Fail on purpose. Attempt something clearly beyond you and watch what happens when the roll comes in low. Does the game master rescue you, or does the result burn you?
• Attack with gear you haven't equipped. Write that you're using a weapon that's in your pack but not equipped. Does the narration behave as though it isn't in your hand?
• Push the cap. Write "I take its head off in one blow." Watch the strike turn into a limited wound, and watch what comes back at you.
• Audit the prose. Read a paragraph aloud. Mark the spot where you hesitate — write to us and that sentence gets fixed in the prompt, not just in the next turn.

Sources and change log#

The outside discussions this page draws on are the long-running arguments between volunteer and professional game localisers and machine-translated "localisation" patches; the reader backlash against publishers who trialled AI-assisted translation; and the tabletop community's own writing on what separates a voice from a register. These aren't our sources — they belong to the side that criticises us, which is the standard a trust document should be held to.

Change log — 20 August 2026: first publication of the page; the two-phase dice flow, the rules table, the boss-death check and the prose flaw list were added. Every correction after this will be written here with its date: if a number changes, you should be able to see which number changed and when.

Frequently asked questions#