Overcoming the Authorial Bottleneck in Interactive Storytelling

31 concepts29 papers1 proposal

Imagine writing a choose-your-own-adventure book. If every choice splits the narrative into two options, a story with just ten choices requires you to write 1,024 unique scenes. Yet, any single reader will only ever experience ten of them.

This dilemma is known as the authorial bottleneck (or content bottleneck). In interactive and automated storytelling, human imagination scales linearly, but branching paths scale exponentially. As Zhiyuan Yang observes in The Impact of Nonlinear Narrative Games on Player Immersion, the immense time and cost required to manually script multiple branching paths often creates a severe trade-off between narrative depth and practical development constraints.

The bottleneck becomes even tighter when we try to build AI-driven storytellers or "Drama Managers." Traditional systems require human experts to hand-code complex domain models, world rules, and character preconditions. As Vadim Bulitko points out in Interactive Narrative: A Novel Application of Artificial Intelligence for Computer Games, the manual effort required to formalize these machine-readable rules often exceeds the effort of writing a traditional script. Furthermore, Steven Poulakos et al. note in Towards an Accessible Interface for Story World Building that explicitly defining how every object alters global states is a labor-intensive, error-prone task that excludes non-technical writers.

To build truly scalable, dynamic story worlds, researchers have shifted away from manual scripting toward data-driven extraction, crowdsourced topology, and declarative constraint systems.


Extracting Narrative Structure from Data

Instead of forcing human experts to write explicit rules for what information to present and when, can an AI learn the implicit structure of a story from existing data?

Early natural language generation systems relied on hand-crafted "content planners" to sequence information logically. To bypass this manual engineering, Pablo Ariel Duboue et al. demonstrated in Empirically Estimating Order Constraints for Content Planning in Generation that motif-discovery algorithms adapted from computational genomics can automatically learn ordering constraints from small datasets of expert speech. To optimize these sequences, Kathleen McKeown et al. used genetic algorithms in Content Planner Construction via Evolutionary Algorithms and a Corpus-based Fitness Function, evaluating generated texts against human transcripts to evolve high-quality content planners across domains.

Beyond information ordering, an AI storyteller must understand the emotional and causal arcs of a plot. Amit Goyal et al. addressed this in Automatically Producing Plot Unit Representations for Narrative Text by using sentiment tools and patient polarity verbs to automatically extract character-centric "plot units" from raw text. Similarly, Josep Valls-Vargas showed in Automated Narrative Information Extraction Using Non-Linear Pipelines that feeding high-level narrative roles (like "Hero" or "Villain") back into low-level NLP tasks allows systems to extract structured story data from complex folk tales without manual annotation.

[Raw Text Corpus] 
       │
       ▼ (Non-Linear NLP Pipelines / Motif Discovery)
[Extracted Structural Beats & Plot Units] 
       │
       ▼ (Case-Based Reasoning / Genetic Optimization)
[Data-Driven Drama Management & Game Generation]

This data-driven philosophy extends directly into game design and drama management. Anders Drachen et al. proposed in Towards Data-Driven Drama Management: Issues in Data Collection and Annotation that instead of hand-coding rules for an AI Game Master, systems can use Case-Based Reasoning to learn how expert human players balance freedom and plot coherence during tabletop RPGs. Taking this to its logical conclusion, Gabriella A. B. Barros et al. developed WikiMystery in Murder Mystery Generation from Open Data, mining open data from DBpedia to procedurally generate logically solvable adventure games without human intervention.


Crowdsourcing the Topology of Common Sense

While extracting structure from existing corpora works well for linear narratives, interactive fiction requires a branching world model that understands what actions are possible in a given situation. If a player is in a bank robbery scenario, the AI needs to know that a robber cannot put money in a bag before opening the bag. Hand-coding these "common sense" prerequisites for every single scenario is impossible to scale.

To solve this, Boyang Li et al. developed the Scheherazade framework. The core intuition behind Scheherazade is simple: while a single human author struggles to write a massive branching tree, a crowd of non-experts can easily write simple, linear stories about a shared scenario.

Crowd Worker 1: Walk to counter ──► Pull out gun ──► Demand money
Crowd Worker 2: Enter bank ──────► Pull out gun ──► Open duffel bag
Crowd Worker 3: Pull out gun ────► Demand money ──► Pack the cash

                               │
                               ▼ (Alignment & Clustering)
                         [ PLOT GRAPH ]
                         ┌────────────┐
                         │ Pull out   │
                         │   gun      │
                         └─────┬──────┘
                               │
               ┌───────────────┴───────────────┐
               ▼                               ▼
       ┌────────────┐                  ┌────────────┐
       │ Demand     │                  │ Open duffel│
       │ money      │                  │    bag     │
       └────────────┘                  └────────────┘

By collecting dozens of these linear descriptions, the system aligns and clusters the sentences to automatically construct a plot graph—a network that captures the causal dependencies and mutual exclusions of an event. As the authors demonstrate in Toward Autonomous Crowd-Powered Creation of Interactive Narratives and Story Generation with Crowdsourced Plot Graphs, the plot graph maps out the permissible narrative space. If 90% of crowd workers pull out a gun before demanding money, the system automatically learns that event A is a prerequisite for event B.

As detailed in Crowdsourcing interactive fiction games and Scheherazade: Crowd-Powered Interactive Narrative Generation, this pipeline generates playable text adventures for arbitrary scenarios without requiring any manual domain engineering. Boyang Li framed this in Narrative Intelligence Without (Domain) Boundaries as a scalable "middle road" for AI: bypassing the technical limitations of fully automated text mining by using strategic crowdsourcing to capture human script knowledge.


Steering Narratives via High-Level Constraints

If we are no longer hard-coding explicit branching paths, how do we ensure that an automated storytelling system remains coherent or respects a designer's high-level goals? The modern solution is to shift from imperative scripting (defining every step) to declarative control (defining the boundaries of the story).

One powerful abstraction is controlling plots through character relationships rather than explicit actions. In Using Social Relationships to Control Narrative Generation, Julie Porteous et al. introduced a system where a user alters character ties (e.g., changing a relationship from "friend" to "antagonist") via a visual interface. The underlying planning engine then automatically calculates valid plot sequences that fulfill that social dynamic, making the system immediately portable to new genres without redefining the underlying logic.

To make these constraints precise without requiring code-heavy engineering, Yu-Zhe Shi et al. proposed in Constraint representation towards precise data-driven storytelling the use of Domain-Specific Languages (DSLs) to establish hierarchical constraints. This creates a "permissible space" where a story can evolve creatively while remaining factually grounded in data.

Other researchers focus on real-time optimization and guidance within these boundaries:

  • Logistical Optimization: In live interactive narratives (like immersive theater or LARPs), managing actors and rooms when player choices branch unpredictably is a logistical nightmare. Sasha Azad et al. solved this in Scheduling Live Interactive Narratives with Mixed-Integer Linear Programming by using Mixed-Integer Linear Programming to dynamically schedule resources on the fly, scaling complex experiences without a proportional increase in manual labor.
  • Personalized Guidance: Rather than authoring redundant narrative transitions for every possible choice, Hong Yu 0010 et al. demonstrated in Toward personalized guidance in interactive narratives that a drama manager can use collaborative filtering to predict player preferences and subtly nudge them toward specific plot points, maintaining the illusion of total agency.
  • Modular Foundations: For open-ended generation, Yan Ma introduced MoPS in MoPS: Modular Story Premise Synthesis for Open-Ended Automatic Story Generation. By deconstructing story premises into separate, hierarchical modules (theme, background, persona, plot) via nested dictionaries, MoPS allows large language models to scale up the synthesis of diverse narrative foundations without losing structural quality.

Ultimately, the future of narrative generation lies in hybrid systems that combine symbolic structure with machine learning flexibility. In Narrative Plan Generation with Self-Supervised Learning, Mihai Polceanu et al. trained deep learning models on synthetic data produced by automated planners. Because the model learns from structured plot sequences rather than raw text, it successfully generates novel, logically consistent narrative plans that preserve the dramatic pacing of a genre.

Coupled with real-time evolutionary algorithms like the cgNEAT framework developed by Erin J. Hastings et al. in Demonstrating Automatic Content Generation in the Galactic Arms Race Video Game, which evolves content dynamically based on player behavior, the field is moving toward a reality where virtual worlds and stories adapt alongside their players—finally breaking the authorial bottleneck.

Key Foundational Work

Content Planner Construction via Evolutionary Algorithms and a Corpus-based Fitness Function (2002) — contributed 1 concept elements to this direction.
Empirically Estimating Order Constraints for Content Planning in Generation (2001) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_authorial_bottleneck_de59f095,
  title = {authorial bottleneck},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/authorial-bottleneck/rdr_de59f095957f4de29377371204b76d0c},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_authorial_bottleneck_de59f095_v1,
  title = {authorial bottleneck},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/authorial-bottleneck/rdr_de59f095957f4de29377371204b76d0c/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake