Looking around at AI writing, especially for novels, it feels like many AI tools (and people) rely on fairly standard techniques. Like basic outlining or simply prompting ChatGPT chapter by chapter. These can work to some extent, but often the results feel a bit flat or constrained.
For the last 8-ish months, I've been thinking about this field a lot.
The challenge with the common outline-first approach
The most common method I've seen involves a hierarchical outlining system: start with a series outline, break it down into book outlines, then chapter outlines, then scene outlines, recursively expanding at each level. The first version of Varu actually used this approach.
Based on my experiments, this method runs into a few key issues:
- Rigidity: Once the outline is set, it's incredibly difficult to deviate or make significant changes mid-story. If you get a great new idea, integrating it is a pain. The plot feels predetermined and rigid.
- Scalability for length: For large-scale narratives (aiming for potentially millions of words), managing and expanding these detailed outlines becomes incredibly complex and potentially limiting.
- Loss of emergence: The fun of discovery during writing is lost. The AI isn't discovering the story; it's just filling in pre-defined blanks.
The plot promise system
This led me to explore a different model based on "plot promises," heavily inspired by Brandon Sanderson's lectures on Promise, Progress, and Payoff. (His new 2025 BYU lectures touch on this. You can watch them for free on youtube!).
Instead of a static outline, this system thinks about the story as a collection of active narrative threads or "promises."
"A plot promise is a promise of something that will happen later in the story. It sets expectations early, then builds tension through obstacles, twists, and turning points—culminating in a powerful, satisfying climax."
Each promise has an importance score guiding how often it should surface. More important = progressed more often. And it progresses (woven into the main story, not back-to-back) until it reaches its payoff.
Here's an example progression of a promise:
ex: Bob will learn a magic spell that gives him super-strength.
1. bob gets a book that explains the spell among many others. He notes it as interesting.
2. (backslide) He tries the spell and fails. It injures his body and he goes to the hospital.
3. He has been practicing lots. He succeeds for the first time.
4. (payoff) He gets into a fight with Fred. He uses this spell to beat Fred in front of a crowd.
Applying this to AI writing
Translating this idea into an AI system involves a few key parts:
- Initial promises: The AI generates a set of core "plot promises" at the start (e.g., "Character A will uncover the conspiracy," "Character B and C will fall in love," "Character D will seek revenge"). Then new promises are created incrementally throughout the book, so that there are always promises.
- Algorithmic pacing: A mathematical algorithm suggests when different promises could be progressed, based on factors like importance and how recently they were progressed. More important plots get revisited more often.
- AI-driven scene choice (the important part): The AI doesn't blindly follow the algorithm's suggestions. Before writing each scene, it analyzes: 1. The immediate previous scene's ending (context is crucial!). 2. All active plot promises (both finished and unfinished). 3. The algorithm's pacing suggestions. It then logically chooses which promise makes the most sense to progress right now. Ex: if a character just got attacked, the AI knows the next scene should likely deal with the aftermath, not abruptly switch to a romance plot just because the algorithm suggested it. It can weave in subplots (like an A/B plot structure), but it does so intelligently based on narrative flow.
- Plot management: As promises are fulfilled (payoffs!), they are marked complete. The AI (and the user) can introduce new promises dynamically as the story evolves, allowing the narrative to grow organically. It also understands dependencies between promises. (ex: "Character X must become king before Character X can be assassinated as king").
Why this approach seems promising
Working with this system has yielded some interesting observations:
- Potential for infinite length: Because it's not bound by a pre-defined outline, the story can theoretically continue indefinitely, adding new plots as needed.
- Flexibility: This was a real "Eureka!" moment during testing. I was reading an AI-generated story and thought, "What if I introduced a tournament arc right now?" I added the plot promise, and the AI wove it into the ongoing narrative as if it belonged there all along. Users can actively steer the story by adding, removing, or modifying plot promises at any time. This combats the "narrative drift" where the AI slowly wanders away from the user's intent. The ability for user intervention via promise management is a significant advantage.
- Intuitive: Thinking in terms of active "promises" feels much closer to how we intuitively understand story momentum, compared to dissecting a static outline.
- Consistency: Letting the AI make context-aware choices about plot progression helps mitigate some logical inconsistencies.
Challenges in this approach
Of course, it's not magic, and there are challenges I'm actively working on:
- Refining AI decision-making: Getting the AI to consistently make good narrative choices about which promise to progress requires sophisticated context understanding and reasoning.
- Maintaining coherence: Without a full future outline, ensuring long-range coherence depends heavily on the AI having good summaries and memory of past events.
- Input prompt lenght: When you give AI a long initial prompt, it can't actually remember and use it all. When you see things like the "needle in a haystack" benchmark for a million input tokens, thats seeing if it can find one thing. But it's not seeing if it can remember and use 1000 different past plot points. So this means that, the longer the AI story gets, the more it will forget things that happened in the past. (Right now in Varu, this happens at around the 20K-word mark). We're currently thinking of solutions to this.
Observations and ongoing work
Developing this system for Varu AI was an iterative process. Early versions produced inconsistent results, but refining the pacing algorithms and the AI's scene-selection logic has yielded outputs that are significantly more coherent and adaptable than those from initial outline-based methods. While considerable refinement is still needed, this approach feels like a promising direction.
