A Chart of the Human Heart The sparse, event-sourced character & world state graph

A language model can write a luminous scene. What it cannot do is hold the whole evolving social world of a novel in its head across a thousand scenes — who has cooled toward whom, who quietly betrayed whom four chapters ago, which faction is slowly turning. So we don't ask it to. The model writes the prose and proposes what changed; a small deterministic graph remembers everything, ripples the consequences to the people off-stage, and hands the next scene exactly the slice it needs.

This note explains the mechanics end to end — the model, the math, the guarantees — and shows them on a real cast generated by the engine: the novella The Drowned Accounts.

---

01Why it exists

The frozen graph

Every scene used to be written with a running recap — "the story so far." That works at fourteen scenes and is fatal at a thousand: the recap grows without bound, and it can never carry the current state of the eighty characters not in this scene. You cannot prompt scene #847 by re-reading 846 scenes of prose.

Worse, the relationships didn't actually move. The engine applied a character's fortune, mood, and beliefs each scene — but a relationship's stance was set once at casting and never mutated. The prose could describe a friendship souring while the modeled state sat perfectly still.

02The model

Nodes, directed edges, four axes

Three kinds of node — characters, factions, locations — joined by typed, directed edges. Directed is essential: A can love B more than B loves A. The relationship edge A → B carries four axes, because a single "affinity" scalar is the best-documented mistake in the field (it makes antagonists who share scenes look "close," and collapses every kind of bond into one number).

A faction carries a slow disposition and an inertia weight; a character's affiliation to it carries its own valence — so a guild member can privately turn against the guild long before the guild itself moves. And a belief may name a subject — "A believes B is loyal" — decoupled from the truth. That gap is the engine of dramatic irony.

The same graph, exactly

from → to	bond	valence	trust	power	stance	trajectory
yara → solen	sibling — she is the y	+0.70	0.75	-0.35	for	cooling
solen → yara	elder sibling and erst	+0.65	0.55	+0.45	for	cooling
yara → veld	former credentialing s	-0.20	0.30	-0.55	neutral	cooling
veld → yara	former credentialing s	-0.35	0.10	+0.70	against	static
yara → nessa	petitioner and eventua	+0.25	0.50	+0.20	neutral	warming
nessa → yara	petitioner who becomes	+0.55	0.65	-0.10	for	warming
solen → veld	fellow councillor held	+0.30	0.35	-0.40	neutral	cooling
veld → solen	fellow councillor held	+0.30	0.45	+0.45	for	cooling

03The mathematics

One deterministic step per scene

The model never overwrites a number. Following Crusader Kings' insight that a relationship is best represented as a list of remembered reasons, each scene proposes named modifiers. An edge's value is its baseline plus the sum of its active modifiers:

where each modifier m has amount a_m, birth-scene s_m, and a decay factor δ_m. This is where the model earns its realism with two clocks:

A permanent modifier moves the durable standing — a betrayal scars. A decaying one is a passing mood that mean-reverts toward the standing value as it ages (dropped once it falls below a small cutoff). RimWorld learned the same lesson: "killed my mother" never decays, but the shock of a shouting match does.

Stance, with hysteresis

The legible band for / neutral / against is derived from valence — but with asymmetric enter/exit thresholds, so a relationship hovering near a boundary doesn't flicker scene to scene (the failure that makes every game's social sim feel mechanical):

with enter margin ε_enter=0.20 and exit ε_exit=0.05. You cross a higher bar to enter a camp than to leave it.

Propagation — the consequence the model can't see

When a scene moves an on-stage edge sharply, the change ripples, in one bounded pass, to the people who aren't in the room. An ally of A cools toward B when A does — balance theory's "the enemy of my friend":

damped by γ<1, capped at one hop, dropped below a magnitude cutoff — guards against runaway on a cyclic signed graph. And one invariant keeps it honest:

Group inertia

A faction is a slow Markov state. Its valence is an inertia-weighted moving average of its members' — so the group always lags the individuals, and a member can defect long before the institution shifts:

04Watch an edge move

Real dialogue · real delta · The Drowned Accounts, scene 3

Pre-production set the standing relationships. Then the dialogist wrote a scene and, alongside the prose, proposed the modifiers it earned. Here is the engine doing the whole loop on one real scene — the confrontation in which Factor Veld clears Yara's desk and strips her credential.

From that scene the dialogist proposed exactly these modifiers — and the graph folded them. Note the separable axes: Yara's valence toward her brother barely moves (she still loves him) while her trust falls hard. And the customs-warden slight is a decaying mood, not a permanent scar:

05Storage & scale

Event-sourced, in SQLite

The materialised graph lives in the story's JSON for short work. At novel scale it is backed by an append-only modifier log plus a per-scene snapshot in SQLite — the event-sourcing pattern. Any past scene reconstructs in O(1) from its checkpoint; a chapter can be repaired without re-running the book; and the log is the inspector's "why" trail. No graph database is needed at tens-to-hundreds of nodes across thousands of scenes. The decay sum is bounded to a fixed look-back window, so the whole pass stays linear in the number of scenes, not quadratic.

Concern	Mechanism	Cost
Bounded context for scene N	k-hop neighbourhood of the present cast	O(neighbourhood)
Off-stage consequences	one damped propagation pass	O(edges·hop)
Reconstruct any past scene	nearest snapshot + fold log	O(1) at per-scene cadence
Two-clock decay over a long book	fixed look-back window	O(1) per edge

06Placing the scenes — the arc-fitter

CP-SAT · OR-Tools · PESP-isomorphic

Each character has an independent fortune curve, and the beats say where several of them must be at the same narrative moment. Making independently-arced lives cross at the right beat is a constraint-scheduling problem — the same shape as a PESP timetable — so we hand it to a CP-SAT solver. Narrative time is discretised into slots; each scene gets a slot variable.

ARC_FIT(beats, characters, scenes):                  # PESP-isomorphic; OR-Tools CP-SAT
  n  <- max(21, |scenes|+1);   grid t_i = i / (n-1)
  F[c][i] <- fortune_c(t_i)                           # sample each independent arc

  var x_s in [0, n-1]                                 # the slot each scene is placed at

  hard:  x_{s+1} >= x_s + 1                           # strictly increasing narrative time
         |x_a - x_b| <= W      for a,b sharing a beat # beat-mates stay together
  soft:  SUM |F[c][x_s] - target_{beat(s),c}|         # present c with a target: hit the arc
         SUM |x_s - slot(authored t_s)|               # don't wander from the plan

  minimise   W_fit * fit  +  W_anchor * anchor
  solve (5s);  t_s <- grid(x_s);   return scenes sorted by t
  # infeasible hard constraints -> raise (bounce to beat-planner); soft misses are reported

One solve per chapter, not one for the book

At novel scale the single global solve is the wrong unit: a hundred scenes pinned across a hundred slots is a model large enough to grind, and the beats of chapter sixteen have nothing to say about the placement of chapter two. So the fitter now runs per chapter — per act. For each chapter it places only that chapter's scenes, bounded to the chapter's own tBounds, so the characters present there have their fortune arcs cross at that chapter's beats. The intractable global solve dissolves into many small, independent, fast ones — each a handful of scenes inside a known window — and the per-act decomposition this section already gestures at becomes literal. A short story is simply the degenerate case: one implicit chapter spanning the whole curve, so it takes the single global solve exactly as before, unchanged.

07The whole machine

End-to-end pseudocode

The model is the brain; Python is the nervous system. Every stage below is a single-purpose Claude Code subagent on the user's subscription; everything in the placement and assemble phases is deterministic Python — no model, no API.

GENERATE_STORY(premise, length):

  # ── pre-production · one Claude Code subagent per stage, on the subscription ──
  setup      -> genre, form, working title
  journey    -> fortune shape (Vonnegut / Reagan) + control points
  summary    -> synopsis
  locations  -> places + the journey DAG
  cast       -> characters (multi-axis edges, beliefs, own arcs) + factions + tension
  beats      -> plot beats on the curve, each with fortuneTargets {char -> fortune}
  storyboard -> N scene titles + purpose
  blocking   -> who is present + where, per scene
  chapters   -> group scenes into chapters (novella / novel)

  # ── placement · deterministic, no model ──
  for each scene:  beatId <- nearest beat by t
  scenes <- ARC_FIT(beats, characters, scenes)      # CP-SAT: arcs intersect at beats

  # ── prose · fractal and parallel ──
  PIN_SEAMS(chapters)                                # boundary states agree (breadth-first)
  PLAN_SCENES(between pinned bounds)                 # parallel, per chapter
  for each scene in parallel (<= GEN_WORKERS):
     repeat up to REVISE_CAP+1 times:
        draft   <- DIALOGIST(scene, NEIGHBOURHOOD, pinned bounds)   # prose + deltas + edgeDeltas
        verdict <- AUDITOR(draft)                    # coherence and fit both >= 0.8 ?
        if verdict = pass: break
     commit draft
  SEAM_AUDIT(every boundary: left <-> right <-> up); repair the broken ones

  # ── assemble · deterministic ──
  for each scene in order:
     apply fortune / mood / belief deltas
     APPLY_GRAPH_STEP(scene)                         # edges, ripple, bands, inertia
     snapshot to the event store                     # novels only
  set each character's final fortune from its arc

08The algorithms

Each deterministic step, in full

The graph step — one transition per scene

APPLY_GRAPH_STEP(scene):                              # one deterministic transition per scene
  for each edgeDelta (from -> to, axis, amount, halfLife?):
     if no halfLife:  edge[axis] <- clamp(edge[axis] + amount)   # permanent = STANDING (slow clock)
     # decaying modifiers are NOT stored; they live in the log and surface via FELT()
  ripples <- PROPAGATE(scene)                         # consequences for the off-stage cast
  UPDATE_GROUP_INERTIA()                              # factions lag their members (Markov)
  DERIVE_BANDS()                                      # stance (hysteresis) + trajectory

Propagation — the off-stage ripple

PROPAGATE(scene):                                     # one bounded pass; on-stage always wins
  for each sharp permanent valence shift a on edge A -> B  (|a| >= THETA):
     for each off-stage X with |val(X -> A)| >= ALLY_MIN:
        ripple <- a * GAMMA * val(X -> A)             # balance theory, damped (GAMMA < 1)
        if |ripple| >= CUTOFF and X->B was not set this scene:
           val(X -> B) <- clamp(val(X -> B) + ripple)

The two clocks — what a character feels

FELT(edge, axis, t):                                  # the value a character currently FEELS
  standing  <- edge[axis]                             # permanent residue (slow clock)
  transient <- SUM  a * (1/2)^((t - s)/h)             # decaying modifiers (s,h) in the last W scenes
  return clamp(standing + transient)                  # mean-reverts to standing as moods fade

The neighbourhood — what replaces the recap

NEIGHBOURHOOD(present, t):                            # bounded ego-graph; replaces the recap
  for each character c in present:
     bonds   <- { to, bond, FELT(valence), FELT(trust), stance, recent reasons }
     groups  <- { faction, standing, FELT(valence), stance }
     beliefs <- c.beliefs   (each with its optional subject)
  factions <- the groups in play
  return the slice   # O(neighbourhood), not O(book) -> a 1000-scene prompt stays flat

09Rupture — the dislocation of expectation

Rare · planned · irreversible

Every mechanic so far smooths: mean-reversion, inertia, hysteresis, damped propagation, an auditor that rewards continuity. Wonderful for coherence — and the enemy of the rug-pull. A rupture is the deliberate exception: a single scene where a high-confidence belief is shattered, dislocating expectation and setting an irreversible outcome in motion (a character flees and the story restarts; innocence is lost). Valve's own words for why it works: "Low probability + High drama = Memorable." So it is rare — at most one per story, usually none — and planned at the beat/arc level, sitting where the fortune curve drops steeply.

At a rupture the usual rules invert: the belief flips in one move (bypassing the gradual linear-threshold), the holder's factions shock in one step (inertia is bypassed — their world is upended), a permanent bond breaks, and the auditor's bar flips — it now passes the scene only if the certainty is genuinely shattered and the outcome irreversible, and it reads as retroactively inevitable. A rupture that stays smooth, hedges, or feels arbitrary is a revise.

10Tension & pacing — the AI Director

After Valve's Left 4 Dead (Booth, GDC 2009)

A story, like a co-op horror game, lives or dies on its pacing. Valve's L4D "AI Director" estimates a per-moment emotional intensity and shapes it into a sawtooth — because "constant, unchanging combat is fatiguing; long periods of inactivity are boring; unpredictable peaks and valleys of intensity create a powerfully compelling experience." We measure the same thing per scene, from state we already model:

PACE(scenes):                          # the AI-Director, per scene (after Booth / Valve, GDC 2009)
  for each scene s in narrative order:
     intensity(s) <- w_t*threat + w_v*volatility + w_c*conflict + w_k*stakes   # in [0,1]

  # the rhythm must be a SAWTOOTH, never a flat line:
  Build-Up      while intensity climbs toward the peak threshold
  Sustain Peak  hold the peak briefly (a scene or two) after it crests
  Peak Fade     ease off — but only relax at a NATURAL break in the action
  Relax         a genuine breather before the next build

  flag if:  BORING (flat-low run) | FATIGUING (flat-high run)
            peak-without-release | front-loaded climax
  # a rupture is a SCRIPTED peak (like L4D's Tank) — exempt from smoothing, but it MUST release after

11Factions — beyond the average, beyond the moment

Influence-weighted · history-bearing

A faction is a node like any other, but its stored valence is a summary of many members' affiliations. The naïve summary — the plain arithmetic mean — is wrong twice over: it treats a guild's founder and its newest initiate as equal votes, and it forgets everything the moment membership shifts. Two fixes, one per subsection.

Not the plain average — who steers the faction

A faction's stance is not a referendum. It is steered by its high-standing members — the leaders and founders whose word carries — and pulled by a vocal minority who feel intensely, while tepid moderates fall quiet. This is settled social science: DeGroot showed group opinion converges as an influence-weighted pool, not an equal one; Katz & Lazarsfeld's two-step flow of communication found that group opinion is mediated by a few opinion leaders; and Noelle-Neumann's spiral of silence explains why the intense are heard and the indifferent are not. So we replace the mean with a weighted pool:

Here w is the faction's inertia — the slow-clock self-weight from §07, unchanged — and ρ is the role weight: how much standing this member's voice carries.

Role	Examples	Weight ρ
steerer	leader · founder · head · chief	3.0
second tier	rival · defector · officer · captain	1.5
rank & file	member · initiate	1.0
marginal	exile · enemy · outcast	0.5
unknown	—	1.0

The intensity term (1+β|v|) is the vocal-minority boost: a member who feels strongly — high |v|, for or against — is louder than one who shrugs. A passionate dissenter outweighs a tepid loyalist; that is the spiral of silence made arithmetic. The crucial safety property: when every member shares the same standing and the same intensity, all ωᵢ are equal and the pool degrades exactly to the plain mean. The new term can only matter when there is genuine asymmetry to honour — so it never destabilises the simple case, and the §07 inertia / lag behaviour is untouched.

A faction remembers — the founding grievance

A scalar valence is Markovian: it depends only on who belongs now, with no memory. Real factions are not. They carry institutional memory — a founding wound, a standing grievance, a "chosen trauma," traditions and prior decisions that bias behaviour regardless of the present mood. A guild born from a massacre acts like it, even in a calm decade. We honour this honestly, and cheaply.

faction_context(f, scene):                   # what the dialogist is handed about a faction
  valence  <- influence_weighted_pool(f)     # §11A — steered, not averaged
  if f.foundingGrievance:                     # ONE permanent scalar string (v0)
     present "PERMANENT — colors this faction in EVERY scene, never decays:"
     present f.foundingGrievance              # the non-decaying floor under the moving valence
  # NOT built for short stories (YAGNI):
  #   memory[] — decaying, half-life-weighted grievances/traditions/triumphs (CK-style)
  #   gated on meta.form == 'novel', where a resurfacing grievance IS a plot beat

12Scale — the book as a hierarchy of arcs

From a flat list to a nested form

Scriptorium began the way every prototype should: a single flat list of six scenes hung on one global fortune curve. That is the right shape for a short story and the wrong one for a novel. A book is not a longer short story; it is a nested thing, and so the engine now grows a hierarchy when the form warrants it — Story → structure[] (the acts) → chapters[] → scenes[] → beats[]. The short story keeps its flat list, untouched; the larger forms acquire the floors above it.

Because the structure is real, the scene budget is now derived from it rather than declared as a flat constant. The arithmetic falls straight out of the hierarchy: a novel is 18 chapters × 4 scenes = 72; a novella is 6 × 3 = 18; a short story stays a flat 6, with no chapters at all. The length of the book is a consequence of its skeleton, not a number chosen beside it.

The structure-planner — a skeleton before any scene

A new pre-production skill, the structure-planner, lays down that act-and-chapter skeleton before a single scene is written. Each chapter is born carrying its own contract: a goal, a value-shift — the emotional polarity it must travel from → to, the same begin-to-end logic as the global shape but local to the chapter — an exit hook to pull the reader across the chapter break, and a point-of-view character through whom the chapter is seen. The book knows what each of its chambers is for before it furnishes any of them.

Chapter-first — growing chapters, not slicing them

This reverses the order of construction. For form ∈ {novel, novella} a structure stage runs ahead of scene generation and grows the chapters from the planned outline — each chapter materialised with its own scene purposes — rather than writing one long flat scene-list and slicing it into chapters after the fact. Build up from intent; do not cut down from a finished slab. The path is gated behind the SCRIPTORIUM_CHAPTER_FIRST environment flag, default-on for those two forms; set it to 0 to fall back to the legacy slice path. A short story never enters the chapter-first path at all — it has nothing to grow.

Holding a long book together

Length introduces a problem the short story never had: continuity that must survive across dozens of chapters a model cannot hold in its head at once. Two additive structures carry it. A Story Bible — meta.bible — is the ledger of canonical facts that every later chapter must stay true to; and threads[] are the running storylines, each tracked across chapters so a promise made in chapter two is paid in chapter sixteen rather than quietly forgotten.

The decisive point is what does not change. The affective machinery of the earlier sections is not replaced by the hierarchy — it scales into it. The arc-fitter of §06, the tension and pacing of §10, and the rupture of §09 now operate across the chapter structure: each chapter is a tension sub-arc nested inside the global shape, with its own build and release, while the whole still rises and falls as one curve. And the event-sourced graph store of §05 persists the character and world state across the entire book — which is precisely what makes novel-length continuity tractable for a model that cannot hold the whole book in its context. The graph remembers so the model need not. The cast scales to match: the casting cap lifts from the 3–5 named characters of a short story to 15–40 in a novel.

13Voice — who tells the story

How it is told, apart from what happens

Everything to here has been a chart of what happens — the heart's motion, the faction's drift, the dislocation of a belief. Distinct from all of it is how the happening is told. The narrator layer gives each story a chosen viewpoint, and that choice colours every line of prose without altering a single fact beneath it. There are four: first, third-limited, omniscient, and fully-narrated.

viewpoint is the authoritative field. The older person field — third versus first — is now derived from it at seed time rather than set independently, so the two can never disagree: first → first, third-limited → third-limited, omniscient → third-omniscient, and fully-narrated → third-omniscient. One field is chosen; the other follows.

Four voices, four instructions

Each viewpoint injects its own prose-instruction block at generation time, so the difference is written into the page and not merely labelled on it.

The interject gate

An interject toggle — meta.narrator.interject — lets the narrator step in with wit or inner monologue even in third person, so a limited or omniscient telling can earn a flash of voice without abandoning its stance. The gate governs only the other three viewpoints: fully-narrated always narrates, by definition, so the toggle leaves it alone and presses only where a narrator's intrusion is a choice rather than a given.

14The unfinished book — resumable generation

Written in chapters, stopped at the seam, resumed where it broke off

A novel cannot — and should not — be written in a single pass. The context window will not hold eighty thousand words, and the cost of trying would be paid for nothing the moment the run faltered. So a long book is generated the way it is read: chapter by chapter, with the freedom to stop between any two and pick the work up later exactly where it was set down.

The mechanism is deliberately spartan: there is no new checkpoint artifact. The persisted StoryState on disk is the checkpoint. A scene is done by a single, legible criterion — it carries audited prose — and that fact is already written into the state the engine saves. Nothing about completion needs to be recorded twice.

Walking the chapters, flushing at each seam

Generation walks the chapters in order. After each chapter it flushes a checkpoint to disk, stamps meta.genProgress — chaptersDone / total, scenesDone / total, and the currentChapterId — emits a progress note, and is free to halt. The chapter boundary is the safe seam: the same seam the structure-planner of §12 furnishes, now doubling as the place a run can be interrupted without leaving the book in an incoherent half-state.

Idempotent restart — finish only the remainder

On restart the engine scans for the first scene without prose and continues there, skipping everything already written. This makes generation idempotent in the strict sense: running a finished book regenerates nothing, and running a half-finished one completes only what remains. A run stopped mid-chapter loses at most the single scene in flight — every chapter sealed before it is already on disk, audited and done.

GET /genstatus surfaces that same progress to the dashboard, so a long run is legible while it is still being written. And this is not merely a recovery convenience — it is the serialization runway itself: write N chapters, pause, resume, repeat, is precisely how an 80–120k-word novel is actually produced. The pause is a first-class part of the method, not an exception to it.

Scriptorium · engine note · generated for The Drowned Accounts. Hero image: Gemini 2.5 Flash Image (the one non-Anthropic call; all text runs on the Claude subscription). Design & validation: docs/DESIGN-character-world-graph.md. Implementation: service/scriptorium_svc/graph.py, graphstore.py. Math typeset with KaTeX.