---
id: story-decompiling-and-remixing
title: Story decompilers exist, but nobody closes the loop
version: 1
published: '2026-10-27'
updated: '2026-10-27'
author: Hiina
produced-by: Claude deep-research run with citation checking
model: claude-opus-5-5
sources-through: '2026-10-26'
status: current
takeaway: Story decompilers and plan-conditioned generators both exist, but nobody
  closes the extract-regenerate-edit loop; it is cheap to start on text, provided
  decoys control for memorised plots.
topics:
- narrative
- story-generation
- llm-evaluation
- generative-media
source-sha256: ee956178de65285555ec9b27670c59c328b3b1989e380ea676476fa81383ce75
---

Index of everything on this site: https://ai.hiina.space/index.md

# Story decompilers exist, but nobody closes the loop

- Author: Hiina (hiina@hiina.space)
- Produced by: Claude deep-research run with citation checking
- Version: 1 · published 2026-10-27 · updated 2026-10-27 · status: current
- Canonical: https://ai.hiina.space/reports/story-decompiling-and-remixing.md (this version as one file: https://ai.hiina.space/reports/story-decompiling-and-remixing/v1.md)
- Takeaway: Story decompilers and plan-conditioned generators both exist, but nobody closes the extract-regenerate-edit loop; it is cheap to start on text, provided decoys control for memorised plots.
- Topics: narrative, story-generation, [llm-evaluation](https://ai.hiina.space/topics/llm-evaluation.md), [generative-media](https://ai.hiina.space/topics/generative-media.md)
- Model: claude-opus-5-5
- Sources through: 2026-10-26

The idea behind this report is a story autoencoder, modelled on game decompilation. Decompile a film or a story into a structured "source code" (scenes, characters, beats, tropes, perhaps an AI-generated TV Tropes page), regenerate the story from that source, and check that the round trip holds. Then remix at the source level, the way decompiled Super Mario 64 gets modded: "Hamlet, but Lovecraftian and gender-swapped." The questions are which parts of that loop already exist, which representations survive the trip, and how to tell a faithful remix from a fluent rewrite.

## 1. Summary

Both halves of a story autoencoder have prior art, but in our searches we found nobody who joins them. On the decompile side, film-to-screenplay systems exist: ScreenWriter (2024) works on whole films and OmniScript (2026) on 5 to 30 minute clips. There is also a long line of text-to-structure extractors for Propp functions, ATU tale types, Thompson motifs, turning points and TV Tropes. On the recompile side, plan-conditioned generators run from Plan-and-Write (2019) through Dramatron and DOC to Agents' Room (2025). What we found none of is a study that does the whole loop at story or screenplay scale: extract a structure from an existing story, regenerate from it, score the reconstruction against the source with controls, then edit the structure and score the edit.

The near-misses are worth knowing exactly. Shen & Ying compress Chinese web novels to outlines and expand them back, measuring distortion, but they make no edits and use no decoys. Chen & Si use story reconstruction as a feedback signal to refine annotation prompts (abstract only). Rewriting Video closes a video-to-text-to-video loop, but only on 8-second clips.

Across the separate pieces, the evidence points one way. Coarse, boundary-tolerant representations come back reliably: event and scene lists, and coarse type labels queried one at a time as a checklist. Named functions, exact beats, tropes, and causal or character-state links do not. GPT-4 reaches at best 27.1 F1 on 95 film tropes, against about 65 for humans. A 2019 model matches turning points 41% of the time on synopses, against 64% for humans. Decoders realise only about 72 to 78% of plan items, and the best book-scale claim checker reaches an F1 of 58.2. That makes decoy controls mandatory, for the same reason any LLM claim checker needs shifted controls. The edit side is thinner still: the only established benchmark edits the ending of a five-sentence story, and LLM "contemporary adaptations" of stories double or nearly quadruple their plot-hole rate. The project is open, cheap to start on text through the API, and its main methodological risk is that a decoder already knows Hamlet, so canonical works will appear to reconstruct from almost nothing.

## 2. Film-to-script decompilers recover dialogue well and names, scenes and causes badly

The most direct answer to "movie to screenplay" is **ScreenWriter** (Mahon & Lapata, 2024). It turns a full film into a screenplay with speaker names, scene breaks and visual descriptions, using a modular pipeline. WhisperX transcribes and diarises the audio. CLIP features plus a minimum-description-length criterion segment the scenes. Speaker faces are matched to IMDb cast photos to name characters. Kosmos-2 captions keyframes into rough action lines. Tested on 175 films averaging 118 minutes, it found 25 to 107 scenes per film against about 151 in the gold scripts (scene ARI 0.375 against 0.278 for the best uniform baseline). It named characters correctly **61% of the time per movie and 66% per line** ([ScreenWriter](https://arxiv.org/pdf/2410.19809)). Its most interesting result is a round-trip proxy. Summaries generated from its decompiled screenplay matched Wikipedia plots better than summaries generated from the real screenplay (ROUGE-1 46.48 vs 42.39). Removing the scene breaks dropped that to 38.87. This does not mean the decompile beats the original. It means a shorter, scene-structured script is a better bottleneck for plot summary than a 29,000-word screenplay, which is the first evidence that structure, not length, carries the plot.

**OmniScript** (2026) treats video-to-script as a trained task. Its output is a hierarchical timestamped script: meta (title, character list), scenes (location, time, mood), then events (character, dialogue, action, expression, audio cue). Its benchmark is 10 full-length works, 1.4K scenes and 16.8K events. Evaluation, though, runs on 5 to 30 minute clips, not whole films ([OmniScript](https://arxiv.org/html/2604.11102)). The per-field profile repeats ScreenWriter's. Dialogue scores 69 to 75 for good systems, while character attribution sits around 39 to 42 for every system, Gemini 3 Pro included, even with a character list supplied. Overall event-level scores on 5-minute clips run from 33 to 44 (Qwen3-VL-235B 33.0; OmniScript-8B 37.7 in the table, 37.0 in the text; Gemini 2.5 Pro 42.9). Open models lean heavily on burned-in subtitles: Qwen3-VL-235B's dialogue score falls from 58.6 to 7.7 without them. The reference scripts came from an automated pseudo-labelling engine refined by human annotators, so they are not independent ground truth. **StoryTeller** shows the one trick that reliably helps naming: decoding identities globally across clips, consistent with diarisation, raises naming accuracy to 0.791 on 3-minute clips. Removing the video drops it to 0.430 ([StoryTeller](https://arxiv.org/html/2411.07076)).

Structure above the scene is weaker still. **NEST** (2026) annotates about 103 narrative events per film across 1,005 films with temporal, causal and flashback relations. Most of those labels are silver, made with LLM help, and the human gold set is only 5 films. Zero-shot relation extraction reached **34.2% F1, and 5 of 7 models scored 0.00 on flashback relations** ([NEST](https://arxiv.org/html/2606.19706)). Gold film-scale structure is tiny everywhere. MovieGraphs, the richest schema (characters, attributes, relationships, interactions with reasons), covers 51 films ([MovieGraphs](https://ar5iv.labs.arxiv.org/html/1712.06761)). This is the lesson every structural-annotation project in a creative domain seems to learn, music included: ground truth is the bottleneck. Any decompiler evaluation at film scale will therefore be a round-trip or proxy evaluation, not a comparison against labels.

Two practical consequences follow. First, if a real screenplay and subtitles exist, aligning script dialogue to subtitles gives timestamps and speaker names almost for free. StoryMovie still uses exactly this method to get who-said-what labels ([StoryMovie](https://arxiv.org/html/2602.21829v1)). The video-only path is the "true decompile" and remains research-grade. Second, ingesting a whole film is cheap. Gemini bills video at roughly 100 tokens per second at default resolution ([Gemini video docs](https://ai.google.dev/gemini-api/docs/video-understanding)). By our arithmetic, a 2-hour film is about 720K input tokens: about $0.36 on Gemini 3 Flash Preview, or about $2.90 on Gemini 3.1 Pro above the 200K tier, before output tokens ([Gemini pricing](https://ai.google.dev/gemini-api/docs/pricing); newer models are listed there too). The binding constraints are output length and degradation on long inputs, not cost. In practice that means chunking by scene and adding a global pass.

## 3. Text-to-structure extraction works for coarse labels and fails for named functions

Folklore and narratology offer a full ladder of candidate "source code" levels. Each has some automatic-extraction evidence, and the pattern across them is consistent. Labels that commit to little (which coarse type, whether a concrete motif is present) are recoverable. Labels that commit to a named function at a precise location are not.

| Representation | Best evidence found | What it says |
|---|---|---|
| ATU tale type, coarse | 82% top-1 on Dutch tales via similarity to labelled variants, as reported in Meder 2016 (secondary); 4-bin ATU F1 0.69 vs 0.68 for a bag-of-words SVM | Retrieval-style labelling works when labelled neighbours exist |
| Thompson motifs, concrete | GPT-4.5 zero-shot yes/no per motif: 98% on 13 Cinderella tales (accuracy includes true negatives) | Plausible for literal motifs in a famous tale; tiny validation |
| Propp functions | ChatGPT/Gemini on 11 folktale synopses: precision 0.37 to 0.46, recall 0.22 to 0.34; human strict-span F1 only 0.22 to 0.27 | Even humans disagree on spans; LLMs weak |
| Turning points (5-beat) | 41.33% total agreement on synopses vs 64% human; 10.6 to 14.2% on screenplay scenes vs 35.5% human | Beats are soft, subjective ranges |
| Film tropes (95) | GPT-4 all-at-once with CoT 15.33 F1 (random 13.97); one trope per query 27.1; humans 64.87 (looser criterion) | Checklist querying is the only working pattern |
| Craft stage patterns | PatternTeller stages, F1 about 0.47 to 0.55 vs 0.74 for direct genre labels | Hero's-journey-style stages do not discriminate genres |
| Claims about a book | Claude-3-Opus summaries about 91% faithful; errors concentrate in character states (38.6%) and events (31.5%) | Event lists verify more easily than causal or state edges |

Sources for the table: [Meder 2016](https://pure.knaw.nl/ws/files/6215609/06_Meder_JAF_129_1_text.pdf), [Meaney et al.](https://arxiv.org/pdf/2411.05593), [Cinderella motifs](https://arxiv.org/pdf/2510.18561), [Gervás & Méndez 2024](https://ceur-ws.org/Vol-3671/paper12.pdf), [Finlayson 2015](https://users.cs.fiu.edu/%7Emarkaf/doc/j3.finlayson.2015.dsh.llc.fqv067_archival.pdf), [Yarlott & Finlayson 2016](https://users.cs.fiu.edu/%7Emarkaf/doc/w12.yarlott.2016.proccmn.7.8-1_archival.pdf), [TRIPOD](https://arxiv.org/pdf/1908.10328), [TiMoS](https://arxiv.org/pdf/2101.07632), [LLM trope limits](https://arxiv.org/html/2409.14324v1), [Kaplan et al.](https://ceur-ws.org/Vol-4202/paper9.pdf), [FABLES](https://arxiv.org/pdf/2404.01261).

Four details change how this would be built. First, **position priors are strong**. On screenplay scenes, a "theory baseline" that just places turning points at their textbook positions scores 8.66% against the best model's 14.18% ([TRIPOD](https://arxiv.org/pdf/1908.10328)). Any beat extractor needs that baseline, much as a template baseline keeps any structural boundary detector honest. Second, the Propp annotation data show **high agreement that a function occurs and low agreement on where**: identification F1 0.76 and Fleiss' kappa 0.92 on the function symbol, but a strict span F1 of 0.27 ([Yarlott & Finlayson 2016](https://users.cs.fiu.edu/%7Emarkaf/doc/w12.yarlott.2016.proccmn.7.8-1_archival.pdf)). That is the familiar split between boundary detection and functional naming seen in other structural-annotation tasks, and it argues for span-tolerant scoring. Third, the trope result generalises into a design rule. Asking for many labels at once fails, and asking one closed-vocabulary yes/no question at a time works ([LLM trope limits](https://arxiv.org/html/2409.14324v1)), as with the Cinderella motifs. Fourth, **few-shot examples did not help ChatGPT on Propp tagging** ([Gervás & Méndez 2024](https://ceur-ws.org/Vol-3671/paper12.pdf)), a hint that the model's prior about Propp drives its output more than the text does.

### Named craft schemas make poor ground truth

Named craft schemas fare worst as ground truth. A 2026 survey of narrative-theory-driven LLM methods ties only Hero's Journey, Freytag, Propp and Truby to LLM papers. It reports no agreement or accuracy figures for any of them, compares no schemes against each other, and names no clear extract-then-regenerate pipeline. It cites Snyder (2005) among screenwriting theories but never treats Save the Cat as a method ([Liu, Joshi & Dawson survey](https://arxiv.org/pdf/2602.15851)). We found no inter-annotator study for Save the Cat, Harmon's story circle, Truby, Polti or Booker. Folklorists' own critiques point the same way. The ATU index has uneven geographic coverage, and Dundes argued that classifying tales by their characters rather than their plot is an error ([Wikipedia: ATU index](https://en.wikipedia.org/wiki/Aarne%E2%80%93Thompson%E2%80%93Uther_Index), secondary). In a Dutch archive of over 42,000 tales, about 40% of stories could not be classified with the folktale indices at all ([Meder 2016](https://pure.knaw.nl/ws/files/6215609/06_Meder_JAF_129_1_text.pdf)). Treat ATU numbers, Propp functions, tropes and beat-sheet slots as optional tags on top of a representation, not as its spine.

### TV Tropes as a vocabulary

TV Tropes deserves a separate note, because "AI-generated TV Tropes" is half of the original idea. It is the largest human-curated vocabulary of mid-level story idioms. PicTropes extracted 18,270 tropes over 5,925 films from a 2016 dump ([PicTropes](https://arxiv.org/pdf/1809.10959)). Its labels are popularity-biased and incomplete: tropes per film rose from about 22 to 83 between 2016 and 2020 ([Tropes in films](https://ar5iv.labs.arxiv.org/html/2006.05380)), so a trope missing from a page is not evidence it is missing from the film, and published F1 scores are lower bounds. Per Wikipedia (secondary), the site's content has been CC BY-NC-SA since July 2012 ([Wikipedia: TV Tropes](https://en.wikipedia.org/wiki/TV_Tropes)). Local, non-redistributed use is the low-risk path.

## 4. Plan-conditioned decoders drop a quarter of the plan and invent the rest

The decoder half is the best-developed part of the literature. Every system since 2018 conditions on some intermediate plan, and the representations form a ladder of compression. At the top are one keyword per sentence (Plan-and-Write), then semantic-role event tuples (Aristotelian rescoring, Ammanabrolu's event 5-tuples), then premise, characters and numbered outline (Re3), then hierarchical outline trees with per-node characters and settings (DOC), then logline to characters to beats to locations to dialogue (Dramatron), and finally role-specialised planning agents writing to a shared scratchpad (Agents' Room). Human raters usually prefer the planned output, but the gains are modest and rarely isolated with a fixed backbone ([Re3](https://arxiv.org/pdf/2210.06774); [DOC](https://arxiv.org/pdf/2212.10077); [Dramatron](https://arxiv.org/pdf/2209.14958); [Agents' Room](https://arxiv.org/pdf/2410.02603)).

The numbers that matter for an autoencoder are adherence numbers, and they are sobering. Plan-and-Write realised only **75 to 78% of its storyline keywords**, and plan fidelity carried only 19.7% of the weight in human preference, against 41.4% for coherence ([Plan-and-Write](https://www.arxiv.org/pdf/1811.05701)). Goldfarb-Tarrant et al.'s story model used 72.0 to 75.5% of plot words and verbs, with the rescored system at the low end ([Aristotelian rescoring](https://arxiv.org/pdf/2009.09870)). DOC's controller raised the share of passages faithful to their outline leaf from **37.8% to 58.5%**. The system rarely strayed from the top-level plan but often missed lower-level details ([DOC](https://arxiv.org/pdf/2212.10077)). Re3 reports an outline-mandated affair that simply never happens ([Re3](https://arxiv.org/pdf/2210.06774)). Agents' Room, the strongest modern system, never measures whether stories follow their plans at all. Its LLM judge correlates with humans at rho 0.62 across systems but only 0.41 per item ([Agents' Room](https://arxiv.org/pdf/2410.02603)). Consistency errors grow with length and cluster mid-story ([ConStory-Bench](https://arxiv.org/html/2603.05890)). DOME's ablation shows what a running fact store buys: removing its temporal knowledge-graph memory raised the conflict rate from 0.56 to 4.52 ([DOME](https://arxiv.org/pdf/2412.13575)).

The gap-filling that makes modern decoders fluent is exactly what a round-trip metric will register as divergence. Ammanabrolu et al. call eventification "a lossy process" and needed a five-model fallback cascade to turn tuples back into sentences ([Story Realization](https://arxiv.org/pdf/1909.03480)). The clearest empirical preview of the bottleneck problem comes from screenwriting. When Lei et al. derived training inputs by decomposing real screenplays ("reverse synthesis"), props and minor characters in the target were missing from the input outline. Training only on such pairs scored 7.14 on their 12-point expert rubric, against 8.06 when mixed with forward-synthesised data ([Beyond Direct Generation](https://arxiv.org/pdf/2510.23163v3)). A plan cannot carry everything, so the decoder invents the rest, and the metric has to separate harmless invention from lost plot.

Granularity evidence is thin. No paper compares logline, beat sheet, scene list and event graph on a common benchmark. The consistent pattern across DOC and DOME is two-level: a stable coarse spine plus per-node expansions with explicit characters and settings that adapt as text is written. This matches the plan-then-realise result that a companion report on two-stage user-styled translation also leans on. On WebNLG, a separate planner cut omissions from 41 to 6 at equal BLEU, but the realiser covered only 66.7% of plan entities on unseen data, against 98.9% on seen data ([Moryossef et al. 2019](https://arxiv.org/pdf/1904.03396)). Story records unlike anything the decoder was trained on will drift the same way.

## 5. The near-misses each stop one step short of a closed loop

The absence claim is narrow, so the neighbours need to be named for exactly what they do. The table lists the closest work found. None combines automatic extraction from an existing story, regeneration, a reconstruction metric with controls, and scored edits.

| Work | What it does | What it does not do |
|---|---|---|
| Shen & Ying 2025 (arXiv 2505.12572) | Compresses 40 Chinese web novels to hierarchical outlines at set ratios, expands back with Gemini 2.0 Flash, and scores semantic, plot, character and style similarity with GPT-4o plus counts of characters and scenes | No edits, no decoy controls, single LLM judge; ratio-fidelity correlation weak (r = 0.129); the paper's R values conflict between its tables, so its "optimal 1%" is configuration-specific |
| Chen & Si 2024 (LREC-COLING) | Agent A writes prompts to pull out "the information needed to reconstruct a story"; Agent B rebuilds the story and feeds back; releases StorySense, 615 annotated stories | Reconstruction is used to refine annotation, not reported as a fidelity curve; no edits; abstract only |
| "Can LLMs Tell Stories Out of Order?" (arXiv 2610.21468, Oct 2026) | Annotated story graphs with causal links and character knowledge for 83 works; regenerates nonlinear tellings from the graph; readers preferred them, an automated judge did not | Graphs are annotated, not extracted (as far as the abstract says); no reconstruction metric, no edits |
| StoryScope (arXiv 2604.03136, COLM 2026) | Converts each human story into a structured 10-dimension template, reverse-engineers a prompt, regenerates five LLM versions | Uses the loop to detect AI-fiction idiosyncrasies, not to measure fidelity or edits |
| Rewriting Video (arXiv 2601.08565) | Gemini 2.5 Pro writes a prompt from a clip, Veo 3 regenerates, Gemini compares and revises; CLIP similarity improved on 24 of 30 clips; includes an edit interface | 8-second clips; the authors list long narratives as future work; none found at film scale |
| R² (ICLR 2025) and Lei et al. reverse synthesis | Extract a causal plot graph from novels (R²) or structured inputs from screenplays (Lei et al.), then generate screenplays | Change of medium, not reconstruction; R² tests on 5 novels with a human margin of 6.8 points over Dramatron |

Sources: [Shen & Ying](https://arxiv.org/html/2505.12572v2), [Chen & Si](https://aclanthology.org/2024.lrec-main.1206), [Out of Order](https://arxiv.org/html/2610.21468), [StoryScope](https://arxiv.org/abs/2604.03136), [Rewriting Video](https://arxiv.org/abs/2601.08565), [R²](https://arxiv.org/pdf/2503.15655), [Beyond Direct Generation](https://arxiv.org/pdf/2510.23163v3).

Other adjacent work has one relevant piece each. YARN extracts and abstracts event units for analogy but does not regenerate ([YARN](https://arxiv.org/abs/2603.29997)). Script-a-Video uses a structured scene script as a video-generation prompt, with no editing procedure ([Script-a-Video](https://arxiv.org/abs/2604.11244)). A node-based editing interface lets users edit story-graph nodes and regenerates them, but does not evaluate edit fidelity ([Node-Based Editing](https://arxiv.org/abs/2511.03227)). EditPropBench measures how edits propagate, but in scientific manuscripts, not fiction ([EditPropBench](https://arxiv.org/abs/2605.02083)). NarraBench maps 78 narrative-understanding benchmarks onto a 50-aspect taxonomy and finds about 27% of it well covered, with no benchmark in its event, schema and causality rows ([NarraBench](https://arxiv.org/pdf/2510.09869v1)). The closed loop is open territory. That is a statement about our searches, which were broad but not exhaustive, not proof that no one has tried.

## 6. Round-trip fidelity needs decoys because the decoder already knows Hamlet

The autoencoder framing has one trap that outweighs every other design question: **a strong decoder's prior does much of the reconstruction**. The in-context autoencoder (ICAE) reconstructs ordinary 500-token passages near-verbatim from 128 memory slots, but random text scores BLEU 3.5 or 0.2 against 99.3 for normal text ([ICAE](https://arxiv.org/pdf/2307.06945)). For stories, a decoder handed "Danish prince, ghost, revenge, poison" will write Hamlet from memory, and the round trip will look nearly lossless with a near-empty schema. The Propp tagging result above, where few-shot examples did not help ChatGPT, shows the same prior on the extraction side. Fidelity experiments therefore need stories the model has not seen: newly written fiction, post-cutoff publications, or pseudonymised and perturbed known works. Canonical works belong in the experiment as a measured memorisation control, not as the test set.

The second trap is a schema that games the metric. Anthropic's Natural Language Autoencoders turn activations into text and back, trained only on reconstruction error. They tested for hidden side channels with meaning-preserving rewrites of the intermediate text (shuffling, paraphrase, translation into French), which caused only small drops in reconstruction quality. They also found the reconstructor a weak per-claim verifier, although removing true claims hurt reconstruction more than removing false ones ([NLA](https://transformer-circuits.pub/2026/nla/)). If a story extractor is ever optimised against round-trip loss, the same paraphrase test is the cheap check that the schema is carrying meaning and not a code.

### No single judge will do

Content-fidelity metrics on narrative are weak, so no single judge will do. On FABLES (26 books from 2023 to 2024, 3,158 annotated claims), the best automatic rater, Claude-3-Opus given the whole book, found unfaithful claims at only **F1 58.2**. Retrieving evidence with BM25 scored 24.9. Omissions appeared in 52 to 85% of summaries, and chronology errors in a third to more than half ([FABLES](https://arxiv.org/html/2404.01261v2)). On STORYSUMM (32 Reddit stories, 96 summaries), no automatic method passed 70% balanced accuracy. Even human labelling protocols disagreed sharply: three experts agreed on only 46% of labels before adjudication ([STORYSUMM](https://arxiv.org/pdf/2407.06501)). LLM judges increasingly prefer LLM-written summaries as overlap with the human reference drops ([Blind to the Human Touch](https://arxiv.org/html/2602.07673v1)). In TTCW, LLM judges' agreement with expert creativity ratings was essentially zero (Cohen's kappa about 0.0) ([TTCW](https://arxiv.org/pdf/2309.14556)). FABLES' error types (character states, events, causal links) are exactly what a lossy round trip produces, and precision-style faithfulness checks miss omissions entirely. Both directions are needed: recall of source claims in the reconstruction, and support of reconstruction claims by the source.

### A "same story" benchmark, and its shortcuts

A "same story" test now exists as a benchmark. SemEval-2026 Task 4 asks which of two candidate synopses is more similar to an anchor. Similarity is defined over abstract theme, course of action and outcomes, and explicitly excludes names and settings. That definition is the invariant wanted under a setting swap. The best systems reached **78% (pairwise LLM track) and 72% (embedding track)**, against an estimated label ceiling of about 89%. Accuracy correlated with genre clustering in embedding space at r = 0.67 ([SemEval-2026 Task 4](https://www.inf.uni-hamburg.de/en/inst/ab/lt/publications/2026-hatzel-et-al-semeval.pdf)). Embeddings partly track genre, not plot, so decoys must be genre-matched. Names are the other shortcut. On unmasked text a general sentence encoder ties a story-specific embedding model at about 95% P@1, but on pseudonymised text the gap opens to 82.6 against 67.3 ([Story Embeddings](https://aclanthology.org/2024.emnlp-main.339.pdf)). Pseudonymise before comparing, or the metric rewards preserved names. That would make "Hamlet in space with new names" look like a different story, and a name-swapped copy look like a new one.

### Budget-matched baselines and decoys

The two remaining design rules come from compression research. ICAE compared its 128 memory slots against a GPT-4 summary of the same 128-token budget, and the slots won 34.1% to 17.6% with 48.3% ties ([ICAE](https://arxiv.org/pdf/2307.06945)). The story analogue is a **plain prose synopsis at a matched token budget**: any structured schema has to beat it, or structure is getting credit for nothing. The human reference point for compression is the Wikipedia plot. MovieSum pairs screenplays of about 29K words with plots of about 714 to 717 words, roughly 40:1 ([MovieSum](https://arxiv.org/pdf/2408.06281)). We found no plot rate-distortion curve in the literature. Building one, with fidelity against tokens for each schema level, is itself a contribution.

The decoy design is the shifted-control pattern familiar from other LLM claim checkers. Score the true source-against-reconstruction pair alongside reconstructions from a same-genre different story, from the source schema with events shuffled, from the schema with one setup fact negated, and from a pseudonymised source. Report the checker's false-pass rate on the decoys next to its pass rate on true pairs. The negated-fact decoy has a ready-made generator in FlawedFictions, which builds plot holes by extracting a first-act fact and contradicting it later ([FlawedFictions](https://arxiv.org/html/2504.11900v3)).

## 7. Edits that stay coherent are local, typed and checked by something other than the writer

The edit half has one mature benchmark, and its lessons transfer more than its scale does. TimeTravel gives a five-sentence story and a counterfactual premise, and asks for an ending rewritten with minimal change: 29,849 human rewrites ([TimeTravel](https://arxiv.org/abs/1909.04076)). Its history is a warning about metrics. A supervised model beat the human references on BLEU-4 (76.63 against 65.12) simply by copying the original ending. BLEU and ROUGE correlated negatively with human judgements of counterfactual adherence ([TimeTravel full text](https://ar5iv.arxiv.org/html/1909.04076)). The field moved to two-sided scores: HMEAN of overlap and entailment, which correlated best with humans at r = 0.50 ([EDUCAT](https://arxiv.org/pdf/2112.05417)), and DTO's delta score, which asks whether the output is closer to the edited reference than to the original ([DTO](https://arxiv.org/html/2605.24885v1)). DTO also shows that **LLMs over-edit**: GPT-4o zero-shot preserved less of the text that should stay unchanged (ROUGE-L 46.9) than a fine-tuned baseline (60.9). For a story remix, that becomes three checks: the requested change is present, the plot is preserved outside the edit's scope, and nothing else drifted.

### Whole-story transposition

Whole-story transposition ("X but Y") has no benchmark we could find, and the closest results predict trouble. StoryTrans, a discourse-level style-transfer system, states outright that "content preservation and style transfer are adversarial" ([StoryTrans](https://arxiv.org/pdf/2208.13423)). FlawedFictions found that LLM-written contemporary adaptations of stories raised the plot-hole rate **from 0.14 to 0.27 (Claude 3.5 Haiku) and to 0.53 (GPT-4o-mini)**. The best detector, Claude 3.5 Sonnet, matched human accuracy at 0.76 on short stories but fell to chance on 2,700-word tales ([FlawedFictions](https://arxiv.org/html/2504.11900v3)). Gender-swap work in narrative is almost all bias auditing. A FairytaleQA study swapped pronouns and gendered nouns by rule and by LLM, but measured a downstream QA model, not story coherence ([FairytaleQA CDA](https://arxiv.org/html/2310.10865v3)). A Portuguese-literature study found LLM rewriting reproduced, and sometimes amplified, gendered role stereotypes ([JBCS 2025](https://journals-sol.sbc.org.br/index.php/jbcs/article/view/5799), abstract only). A "gender-swap, keep plot" instruction can therefore silently reassign roles. In Hamlet, succession, marriage and the Ophelia plot all depend on gender, and no published work tests whether such dependencies propagate. StoryAnalogy gives a candidate invariant for transposition. Its analogy score is high when relational structure matches and entities differ. ChatGPT identified such analogies about 30% of the time, against 85.7% for humans ([StoryAnalogy](https://arxiv.org/pdf/2310.12874)).

### External checking

Two findings argue for putting the checking outside the writer. Wang & Kreminski found frontier models handle causal soundness in small narrative-planning domains, but character intentionality is much harder: o1 and Claude 3.7 scored 14 and 15 of 30 on the Aladdin domain. External calibration lifted gpt-4o from 13 to 29 of 30 on causal soundness ([Wang & Kreminski](https://arxiv.org/html/2506.10161v1)). That is the classic narrative-planning line, IPOCL treating a story as a causally and intentionally valid plan ([Riedl & Young](https://jair.org/index.php/jair/article/view/10669)), returning as a verifier. Long-horizon consistency stays poor without such structure: in interactive narratives, the best model's survival rate after 20 turns was 42%, and fact conflicts appeared in 40 to 68% of runs across models ([NCP-Bench](https://arxiv.org/abs/2608.08160), abstract only). Compound requests will also degrade by count. The FollowBench numbers that also matter for styled translation apply directly: GPT-4's hard-constraint satisfaction fell from 84.7% at one constraint to 61.9% at five ([FollowBench](https://arxiv.org/pdf/2310.20410)). "Hamlet but Lovecraftian and gender-swapped" is at least three stacked constraints on top of plot fidelity.

### Lessons from folklore and game decompilation

Folklore and game decompilation both suggest the same layering for the representation. Folklorists treat the **tale type** as a self-sufficient plot and the **motif** as the smallest recombinable element ([Harvard tale-type guide](https://guides.library.harvard.edu/folk_and_myth/indices)). Von Sydow's ecotype describes tales adapting their surface to local conditions while stabilising within cultural districts ([JEF 2019](https://reference-global.com/article/10.2478/jef-2019-0004), abstract level). "Shakespeare recast in another setting" is the same move: hold the type, swap the local layer. The Super Mario 64 decompilation is remixable because of three properties. It can be checked against the original ROM's hash, with `NON_MATCHING` builds that are "functionally equivalent" but not byte-identical. It separates code from data such as levels, behaviours and text, re-extracting the assets from the user's own ROM. And it exposes named, typed entities ([n64decomp/sm64](https://github.com/n64decomp/sm64)). N64Recomp supports mods by replacing functions ([N64Recomp](https://github.com/N64Recomp/N64Recomp)). Cross-game ports mostly wrap or reimplement the guest rather than translating it. Mario in Elden Ring reportedly uses libsm64 ([unwire.hk](https://unwire.hk/2026/10/05/elden-ring-mario-64-mod-er-mario-2/fun-tech/), secondary), and IW4L is a from-scratch Rust rewrite of Modern Warfare 2 ([Held Games roundup](https://heldgames.com/guides/minecraft-inside-other-games-trend), secondary). The analogy holds in one direction and breaks in another. Stories have no executable semantics, so there is never a "matching" build. The best available is "NON_MATCHING but functionally equivalent", judged by lossy checks. What transfers is the architecture: one source of truth with checkable claims, persistent state separated from events, and edits at named interfaces rather than arithmetic on a global latent.

Re-cut trailers mark the boundary of that interface. Robert Ryang's family-comedy cut of *The Shining* left the footage untouched and changed only music, voice-over and shot order ([Wikipedia: Re-cut trailer](https://en.wikipedia.org/wiki/Re-cut_trailer), secondary). Much of genre lives in framing variables. A real Lovecraftian Hamlet changes motivations and causal mechanics, though, which re-framing cannot do. Industry already runs this layering forward. A series bible holds persistent facts (names, a favourite bar, a food allergy) for continuity ([Wikipedia: Bible](https://en.wikipedia.org/wiki/Bible_(screenwriting)), secondary). Beat boards hold movable event cards colour-coded by storyline ([Final Draft](https://www.finaldraft.com/blog/what-is-a-beat-board-anyway)). Dramatron's logline, characters, beats, locations and dialogue ladder mirrors this ([Dramatron](https://arxiv.org/pdf/2209.14958)).

### A four-layer schema

The schema this evidence supports has four layers. The first is a logline and theme. The second is a bible of entities, each with a narrative role (Proppian function) kept separate from identity attributes (name, gender, species), plus world rules and a setting layer. The third is ordered scene cards: participants, location, goal, outcome, state changes, and who knows what. The fourth holds optional soft tags (ATU type, Propp function, tropes, beat names, an emotional arc), each queried as a checklist. Edits then sort into three classes. Identity and surface swaps (names, pronouns, setting nouns) are closed-class and belong in code, the same conclusion the companion translation report reaches for honorifics. Setting swaps replace the world layer and need a propagation pass over the scene cards. Genre changes rewrite motivations and causal links, and are the only class that should go to an LLM planner plus an external consistency check. Emotional arcs fit in the fourth layer as a cheap, deterministic control signal, not as the latent. Reagan et al. themselves say the arc "does not give us direct information about the plot" ([Reagan et al.](https://arxiv.org/pdf/1606.07772)).

## 8. Five experiments, cheapest first

The experiments below share one corpus and one scorer, so each later step reuses the earlier ones. The cost estimates are our own rough arithmetic, not sourced figures.

### Experiment 1. Schema rate-distortion on short unseen stories (API only, tens of dollars)

Take 50 to 100 short stories (1,000 to 3,000 words) that no model has seen: stories written for the experiment, post-cutoff publications that can legally be used, or pseudonymised and perturbed Gutenberg tales such as FlawedFictions' originals. Compress each to five levels: logline; ATU, Propp and trope tags only; beat sheet; scene cards plus bible; and a prose synopsis at the same token count as the scene cards. Expand each back with a model from a different family than the extractor, to blunt self-preference. Score each reconstruction three ways. First, claim recall and precision: extract atomic claims from source and reconstruction, then check each against the other with whole-text context, FABLES-style. Second, answer source-derived questions from the reconstruction alone. Third, run a SemEval-style pairwise same-story judgement against genre-matched decoys after pseudonymisation. Run the decoy set (shuffled schema, negated-fact schema, other-story schema) through the same scorer and report the false-pass rate, as with any shifted-control checker. The output is the first plot rate-distortion curve. It answers whether any structured schema beats a prose synopsis at equal budget. Add Hamlet, Cinderella and two or three other canonical works, both raw and pseudonymised, as a memorisation arm. The gap between their fidelity and the unseen stories' fidelity measures how much the decoder's prior does the work.

### Experiment 2. Single typed edits, schema-side against prompt-side (API only, tens of dollars)

On the same stories, apply one edit at a time: a setting swap, one character's gender, one Propp function (the villain's motive, or the ending's outcome), and one negated setup fact. Do each edit two ways. In one, edit the schema and expand. In the other, ask a strong model to rewrite the full original text with the same instruction ("rewrite this story so that..."). Score three things: edit adherence (targeted attribute QA on the output), invariance (claim recall outside the edit's scope after neutralising the edited attribute, a DTO-style delta against the original), and new contradictions (a FlawedFictions-style plot-hole check plus a scene-card consistency ledger). This is the experiment that tests the core hypothesis, that a mid-level representation makes edits more precise than prompting. The literature predicts the prompt-side baseline will over-edit and add plot holes. The open question is whether schema-side edits leave stale dependencies, such as an unchanged succession plot after a gender swap, that the expander papers over.

### Experiment 3. Stacked edits and the deterministic layer (API, under a hundred dollars)

Apply one to four simultaneous edits (setting, gender, genre, era) and plot adherence, invariance and contradiction rates against edit count, following FollowBench's design. Run every condition twice: once with closed-class edits (names, pronouns, setting nouns) applied in code to the bible before expansion, and once with every edit given to the LLM. If the curves split at two or three edits, as FollowBench predicts for open models, that sets how much the deterministic layer must absorb. A Lovecraftian, gender-swapped Hamlet is the showcase case for this run, after the pseudonymisation control in experiment 1 has measured memorisation.

### Experiment 4. A local expander on a single 24 GB consumer GPU (one to two days of GPU time)

Fine-tune a 7 to 8B model (Qwen-class, LoRA) as the expander. Train on (scene cards plus bible, story) pairs from experiment 1's extractor run over a few thousand public-domain or licensed stories. Mix in forward-synthesised pairs, which Lei et al. found fixes the input-output misalignment of reverse-only data. Compare its round-trip curve with the API expander's. SuperWriter's distilled 7B came within 0.04 of DeepSeek-R1's overall WritingBench score (8.51 against 8.55), which suggests the gap may be small ([SuperWriter](https://arxiv.org/pdf/2506.04180v1)). A local expander makes the large sampling sweeps of experiments 2 and 3 nearly free. If the extractor is later optimised against round-trip loss, add the NLA-style paraphrase test on the schema to rule out side channels.

### Experiment 5. Screenplay-scale round trip, then film (a few dollars per film plus human time)

Move up to screenplays. MovieSum supplies 2,200 cleanly formatted screenplays paired with Wikipedia plots ([MovieSum](https://arxiv.org/html/2408.06281v1)). Decompile each screenplay to scene cards in chunks, regenerate a screenplay, and score it against the real one. Use scene alignment, dialogue overlap for the scenes that survive, the claim scorer from experiment 1, and ScreenWriter's protocol of checking that a summary of the regeneration agrees with the Wikipedia plot. Use films released after the models' cutoffs where possible, and treat famous films as memorisation controls. Only then add the video path: per-scene Gemini ingestion of legally owned films, aligned to subtitles and compared with the real screenplay. That gives the first whole-film video-to-script evaluation against true screenplays that we found. Expect character naming and scene boundaries to be the weak fields, as in ScreenWriter and OmniScript. Plan for screenplay rights and the films' own licences to limit what can be published, even where the experiment itself is cheap.

## 9. Conclusion

The question is not only "has anyone decompiled a story" but "what would make story decompilation as checkable as a matching game decomp." The answer the evidence gives is uncomfortable: nothing will, because no story has a hash. What can be built is the analogue of a `NON_MATCHING` build with a test suite. The suite is claim recall, same-story judgements and contradiction checks. It earns trust only through decoys, because LLM judges have been shown repeatedly to reward length, overlap, names and their own prose. Other LLM-judged annotation work, in music for one, has found the same pattern and the same fix. Seen this way, the round trip is less a training objective than a ground-truth generator for a field whose human gold sets are measured in dozens of films and fifteen folktales.

The more novel insight is about where the latent should live. Folklore's type, motif and ecotype layering, industry's bible-plus-beats split, and the decomp world's code-data split all locate remixability in separating persistent identity from narrative function and from local surface, not in a dense global embedding. If experiments 1 to 3 show that a typed scene-card schema beats a prose synopsis at equal budget, and that schema-side edits produce fewer plot holes than prompt-side rewrites, that would be the first quantitative evidence that "story source code" exists in a useful sense. If not, the result is still publishable and useful: it would show that frontier models carry plot in prose about as well as in any schema, and that the remaining remix problem is consistency checking, not representation.

## 10. Sources

- [ScreenWriter (Mahon & Lapata)](https://arxiv.org/pdf/2410.19809)
- [OmniScript](https://arxiv.org/html/2604.11102)
- [StoryTeller (v3)](https://arxiv.org/html/2411.07076)
- [NEST](https://arxiv.org/html/2606.19706)
- [MovieGraphs](https://ar5iv.labs.arxiv.org/html/1712.06761)
- [StoryMovie](https://arxiv.org/html/2602.21829v1)
- [Gemini API video understanding](https://ai.google.dev/gemini-api/docs/video-understanding)
- [Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing)
- [Meder 2016, Journal of American Folklore (reports Nguyen et al. 2013, secondary)](https://pure.knaw.nl/ws/files/6215609/06_Meder_JAF_129_1_text.pdf)
- [Meaney, Alex & Lamb, folktales in low-resource languages](https://arxiv.org/pdf/2411.05593)
- [Cinderella motif study (Arčon, Robnik-Šikonja, Tratnik)](https://arxiv.org/pdf/2510.18561)
- [Gervás & Méndez 2024, Propp tagging with LLMs](https://ceur-ws.org/Vol-3671/paper12.pdf)
- [Finlayson 2015, ProppLearner](https://users.cs.fiu.edu/%7Emarkaf/doc/j3.finlayson.2015.dsh.llc.fqv067_archival.pdf)
- [Yarlott & Finlayson 2016, ProppML](https://users.cs.fiu.edu/%7Emarkaf/doc/w12.yarlott.2016.proccmn.7.8-1_archival.pdf)
- [TRIPOD (Papalampidi, Keller & Lapata)](https://arxiv.org/pdf/1908.10328)
- [TiMoS trope detection](https://arxiv.org/pdf/2101.07632)
- [LLM trope limits ("Unveiling Narrative Reasoning Limits of LLMs with Trope in Movie Synopses")](https://arxiv.org/html/2409.14324v1)
- [Kaplan, Shmilovici & Last, Structural Patterns in Award-Winning Novellas](https://ceur-ws.org/Vol-4202/paper9.pdf)
- [FABLES (Kim et al.)](https://arxiv.org/pdf/2404.01261)
- [Liu, Joshi & Dawson, narrative-theory-driven LLM methods survey](https://arxiv.org/pdf/2602.15851)
- [ATU index (Wikipedia, secondary)](https://en.wikipedia.org/wiki/Aarne%E2%80%93Thompson%E2%80%93Uther_Index)
- [PicTropes](https://arxiv.org/pdf/1809.10959)
- [Tropes in films, 2020 re-scrape](https://ar5iv.labs.arxiv.org/html/2006.05380)
- [TV Tropes (Wikipedia, secondary)](https://en.wikipedia.org/wiki/TV_Tropes)
- [Re3 (Yang et al.)](https://arxiv.org/pdf/2210.06774)
- [DOC (Yang et al.)](https://arxiv.org/pdf/2212.10077)
- [Dramatron (Mirowski et al.)](https://arxiv.org/pdf/2209.14958)
- [Agents' Room (Huot et al., ICLR 2025)](https://arxiv.org/pdf/2410.02603)
- [Plan-and-Write (Yao et al.)](https://www.arxiv.org/pdf/1811.05701)
- [Aristotelian rescoring (Goldfarb-Tarrant et al., "Content Planning for Neural Story Generation with Aristotelian Rescoring")](https://arxiv.org/pdf/2009.09870)
- [ConStory-Bench, "Lost in Stories"](https://arxiv.org/html/2603.05890)
- [DOME (Wang et al.)](https://arxiv.org/pdf/2412.13575)
- [Ammanabrolu et al., Story Realization](https://arxiv.org/pdf/1909.03480)
- [Beyond Direct Generation (Lei et al., reverse synthesis for screenwriting)](https://arxiv.org/pdf/2510.23163v3)
- [Moryossef et al. 2019, Step-by-Step](https://arxiv.org/pdf/1904.03396)
- [Shen & Ying, optimal expansion ratio](https://arxiv.org/html/2505.12572v2)
- [Chen & Si, Reflections & Resonance (LREC-COLING 2024, abstract only)](https://aclanthology.org/2024.lrec-main.1206)
- [Can LLMs Tell Stories Out of Order? (arXiv 2610.21468)](https://arxiv.org/html/2610.21468)
- [StoryScope (COLM 2026)](https://arxiv.org/abs/2604.03136)
- [Rewriting Video (Wang, Truong, Chilton, Li)](https://arxiv.org/abs/2601.08565)
- [R² (Lin et al., ICLR 2025)](https://arxiv.org/pdf/2503.15655)
- [YARN (abstract level)](https://arxiv.org/abs/2603.29997)
- [Script-a-Video (abstract level)](https://arxiv.org/abs/2604.11244)
- [Node-Based Editing for Multimodal Generation (abstract level)](https://arxiv.org/abs/2511.03227)
- [EditPropBench](https://arxiv.org/abs/2605.02083)
- [NarraBench](https://arxiv.org/pdf/2510.09869v1)
- [ICAE (in-context autoencoder)](https://arxiv.org/pdf/2307.06945)
- [Natural Language Autoencoders (Anthropic, 2026)](https://transformer-circuits.pub/2026/nla/)
- [FABLES (Kim et al.)](https://arxiv.org/html/2404.01261v2)
- [STORYSUMM](https://arxiv.org/pdf/2407.06501)
- [Blind to the Human Touch (judge bias)](https://arxiv.org/html/2602.07673v1)
- [TTCW, "Art or Artifice?"](https://arxiv.org/pdf/2309.14556)
- [SemEval-2026 Task 4 overview (Hatzel et al.)](https://www.inf.uni-hamburg.de/en/inst/ab/lt/publications/2026-hatzel-et-al-semeval.pdf)
- [Story Embeddings (Hatzel & Biemann, EMNLP 2024)](https://aclanthology.org/2024.emnlp-main.339.pdf)
- [MovieSum](https://arxiv.org/pdf/2408.06281)
- [FlawedFictions](https://arxiv.org/html/2504.11900v3)
- [TimeTravel (Qin et al.)](https://arxiv.org/abs/1909.04076)
- [TimeTravel (Qin et al.)](https://ar5iv.arxiv.org/html/1909.04076)
- [EDUCAT (Chen et al.)](https://arxiv.org/pdf/2112.05417)
- [DTO (Girard & Piccardi)](https://arxiv.org/html/2605.24885v1)
- [StoryTrans](https://arxiv.org/pdf/2208.13423)
- [FairytaleQA counterfactual data augmentation](https://arxiv.org/html/2310.10865v3)
- [JBCS 2025, gender bias in Portuguese-language rewriting (abstract only)](https://journals-sol.sbc.org.br/index.php/jbcs/article/view/5799)
- [StoryAnalogy](https://arxiv.org/pdf/2310.12874)
- [Wang & Kreminski, narrative planning perspective](https://arxiv.org/html/2506.10161v1)
- [Riedl & Young, Narrative Planning (JAIR, abstract only)](https://jair.org/index.php/jair/article/view/10669)
- [NCP-Bench, "Can LLM Agents Stick to the Script?" (abstract only)](https://arxiv.org/abs/2608.08160)
- [FollowBench](https://arxiv.org/pdf/2310.20410)
- [Harvard Library guide, tale types and motifs](https://guides.library.harvard.edu/folk_and_myth/indices)
- [Ecotype article, Journal of Ethnology and Folkloristics (abstract level)](https://reference-global.com/article/10.2478/jef-2019-0004)
- [n64decomp/sm64](https://github.com/n64decomp/sm64)
- [N64Recomp](https://github.com/N64Recomp/N64Recomp)
- [unwire.hk, Elden Ring Mario 64 mod (secondary)](https://unwire.hk/2026/10/05/elden-ring-mario-64-mod-er-mario-2/fun-tech/)
- [Held Games, Minecraft-inside-other-games roundup (secondary)](https://heldgames.com/guides/minecraft-inside-other-games-trend)
- [Re-cut trailer (Wikipedia, secondary)](https://en.wikipedia.org/wiki/Re-cut_trailer)
- [Bible (screenwriting) (Wikipedia, secondary)](https://en.wikipedia.org/wiki/Bible_(screenwriting))
- [Final Draft, What is a Beat Board](https://www.finaldraft.com/blog/what-is-a-beat-board-anyway)
- [Reagan et al., emotional arcs](https://arxiv.org/pdf/1606.07772)
- [SuperWriter](https://arxiv.org/pdf/2506.04180v1)
- [MovieSum](https://arxiv.org/html/2408.06281v1)

---

Text licensed CC BY 4.0 (attribution: Hiina, ai.hiina.space). Source: https://github.com/hiinaspace/ai-hiina-space