How AI Stories End, and Why Endless Isn't a Story

How AI stories end is decided by somebody, and in a generated story that somebody is usually you. An authored story carries its ending inside it as a written state the program can reach. A narrator writing each scene on request has no such state, and will keep going for as long as you keep asking. Closure becomes a move you make rather than a place you arrive at.

• In the Inform 6 library the whole game runs inside a loop that exits only when the global deadflag stops being zero.
• deadflag is documented as 1 for dead, 2 for victorious, and higher numbers for exotic forms of death.
• The ink compiler refuses to let a story simply stop, warning about a loose end where the flow runs out.
• ChoiceScript requires every nested block to conclude with *finish or a jump somewhere else.
• A live narrator has no equivalent flag, so an endless story is not a longer story but an unfinished one.

Why doesn’t an AI story end by itself?

Because nothing inside it is checking whether it should. In a traditional text adventure the check is explicit and central. The Inform 6 standard library runs the entire game inside one loop, written in parser.h as while (~~deadflag) and annotated in the source with the comment “everything happens in this loop.” Play continues while that variable is zero. The moment it is not, the loop exits and the game is over.

A narrator has no such variable. Its loop condition is you: a scene arrives, you write a move, another scene arrives. There is no state the system is trying to reach and no test it performs between turns to ask whether the story is finished. Ask for a hundredth scene and you will get one, written as competently as the ninth. Nothing is wrong, and nothing is ending.

That is worth saying plainly because “infinite” is usually sold as the feature. It is more accurate to call it the absence of a feature. An open-ended generator gives you more text; it does not give you the thing that makes text feel like a story rather than a log, which is the sense that the questions raised earlier have been answered.

What an ending is in authored interactive fiction

It is a piece of machinery, and every form in the medium has one. The same file that declares Inform’s loop also declares its ending in a single line: Global deadflag; with the comment “Normally 0, or false; 1 for dead / 2 for victorious, and higher numbers / represent exotic forms of death.” An entire category of narrative experience compressed into one integer.

The choice-based tools are just as insistent. ink warns the author when a story can run out — “Apparent loose end exists where the flow runs out. Do you need a ‘-> END’ statement, choice or divert?” — and reports a runtime error if it happens anyway. ChoiceScript’s documentation is equally firm: “every indented (nested) block must conclude with either a *finish command (which ends the scene) or a *goto line which jumps to another line in the scene.”

Read those three together and a rule appears. In hand-authored interactive fiction, an ending is mandatory and mechanical. The tools will not let you forget one, because a story that cannot stop is a bug.

Form	What marks the end	What happens without it
Parser game (Inform 6)	deadflag set to 1, 2 or higher	The main loop never exits
ink	A -> END divert	A compile warning, then a runtime error
ChoiceScript	*finish closing the block	The documentation treats it as invalid
A live narrator	Nothing in the system	The next scene is written when you ask

The bottom row is the whole difference. It also explains why the older forms feel finished and the newer ones often do not, whatever the interface asks you to type or tap.

How AI stories end in practice

Four ways, and only one of them is accidental. Knowing which you are using is most of the work, because the passive route is the one that leaves a story feeling like it evaporated rather than concluded.

• You stop reading. The most common ending, and the least satisfying. Nothing was resolved; you simply saw the last scene you were ever going to see, without knowing it at the time.
• You steer. You spend the last several moves closing threads deliberately, the way a novelist spends a final chapter. This produces the best endings and takes the most attention.
• You ask outright. You write a move that requests finality — going home, closing the door, saying the thing that has been unsaid. A narrator will generally oblige, because you have told it what shape the scene should have.
• The app closes it for you. Some systems will write a final scene on request rather than leave a story hanging.

Fabledrift, an interactive fiction app for Android, takes the last of those as a rule: a story is never left half-finished. When your credits run out you can carry on with the Apprentice, the free narrator, or ask for a closing scene at no cost. That is a small design decision with a large effect, because the alternative is a story that stops mid-sentence for a reason that has nothing to do with the story.

How to write the last few moves

Treat the ending as something you compose, not something you wait for. Four habits do most of the work, and none of them require you to know what the last line will say before you write toward it.

Name what is still open

Before you decide to finish, list what the story has promised: a person waiting somewhere, a debt, a question asked in scene three and never answered. That list is your ending. A conclusion feels earned when it touches most of it, and thin when it touches none. The narrator is tracking these threads too, which is why characters who remember what you did are the ones worth returning to at the close.

Narrow the place and the cast

Endings tighten. Move your character somewhere specific and bring the two or three people who matter into it, rather than trying to resolve a story from the middle of a road. A scene with a fixed location and a small cast gives the narrator far less room to open something new, which is exactly what you want in the final stretch.

Ask for the shape, not just the action

“I go back to the gate” is an action. “I go back to the gate to say goodbye to her, for the last time” tells the narrator what the scene is for. Stating the purpose out loud is the single most reliable way to get a final scene that reads as final, since the prose is written from what you asked for.

Let it be quiet

The pull of a generative system is toward escalation, because escalation is always available. Resist it near the end. A last scene that lowers the stakes deliberately — an ordinary conversation, a walk back, a door closing — reads as an ending in a way another catastrophe never does.

What an endless story costs you

It costs you the story. Without a last page there is nothing to re-read, nothing to describe to somebody else, and no moment at which the earlier scenes acquire their meaning. Length is not the problem; forty scenes that resolve are worth more than four hundred that continue. The pleasure of fiction is largely retrospective, and retrospection needs a place to stand.

There is a practical cost too. A finished story is a thing you can keep. Once you have written the last move, the transcript stops being a session and becomes a text with a shape, which is when saving a story as plain text starts to be worth doing. An unfinished one is just where you happened to stop.

Calling the last page

The old parser games put the ending in a variable and the choice-based tools put it in a required statement. Both admit the same thing: somebody has to decide when a story is over, and in those forms it was the author, in advance. In a story written live, that decision moves to you, and nothing on the page will remind you that it is yours to make.

So make it on purpose. Notice when the threads you cared about have been answered, spend three or four moves closing rather than opening, and then write the move that stops. The narrator will meet you there. It has been waiting for someone to say when.