Explore the fate of a world.

The artifact is the novel, and the practice is the causal exploration of fate. Meridians is a creative studio with a single subject — fate, the art and science of possibility — and a single method: record a world completely enough that its futures can be simulated forward instead of imagined. It is built for total recall without total attention: give it a canon, a corpus, a premise, or a maintained source and it builds a Domain — a world of actors, rules, evidence, relationships, commitments, open questions, and remembered change. It then explores how that world's fate could diverge, prices the possibilities against what is already true, and prepares the timelines that earn it as something a person can enter: an explorable visual novel with many routes and many endings. Because the variables are recorded rather than described, the branches are parallel worlds that can be compared — same rules, same cast, different history — rather than alternate takes asserted side by side, and each one diverges because a Will outside the simulation chose and the world computed the rest. The world remains recoverable; the reader sees the passage that matters now.

Meridians competes with the book. The proposition is a better book, and it is specific: consequence (a choice moves typed world state and the world computes what follows, so the other branch is a different story rather than the same pages again), meaning (a theme is a pattern the record keeps producing, shown with the events that support it), perspective (a seat reads only what it could know, remember, reach, and afford), and immersion (sprites, plates, artifacts, and the discipline of a scene, prepared before reading). A book gives one path through a world; a prepared Meridians novel gives the world — replayable, POV-switchable, and illustrated. It is the alternative to reading for roleplay-minded people: the reader is not a spectator to a resolution already reached but the one who commits at the fork, and a second run down the other branch is a different story rather than the same pages again. Its lineage is two: the choose-your-own-adventure, which gave the reader the fork, and the visual novel, which gave the fork a craft — sprites, backdrops, routes, endings, and the discipline of a scene. Meridians adds the third thing neither had: a world underneath that computes what the fork costs. A Domain is inhabited three ways — you decide in a Scenario, the card table where a move resolves; read an Experience, the prepared novel; and wander a World along its own timeline, roleplaying inside a recorded moment — and they are peers, not a ladder. Its first useful configuration is still practical intelligence: Research gathers sources, the Program maintains interpretation, and the Graph makes the living model inspectable. Scenario extends the same Domain into consequential play. The visual novel is the consumable form that machinery exists to produce, and a branch-derived World remains an optional experiment rather than a required destination.

The mechanism is maintained Domain state. Archival memory keeps sources and provenance reachable. Structural memory keeps the actors, systems, evidence, relationships, and causal history coherent. Working memory foregrounds the recent and load-bearing detail needed for the question at hand. A feed or isolated model answer is a snapshot; Meridians preserves the world around it.

The relationship rests on a deliberate division of labour: System constrains; World embodies; Fate remains open; Will makes the move. Will is not a fourth stored force — it is injected from outside the simulation, by a reader at a fork, a group at the card table, a Director steering the Program, or an autonomous agent acting through MCP. A model continuing a narrative produces another plausible page; an injected Will produces a divergence with an author, and the record keeps who moved, from what vantage, under which rules, knowing what. That is what makes a branch a parallel world rather than an alternate take, and it is the ceiling on automation: exploration may propose and price futures, but nothing in the engine may quietly make the commitment on a participant's behalf. Frames describe perception; Control determines Unit power. MCP gives a resulting choice a typed, attributable form. The engine supplies context and affordance; it does not claim authorship of the choice.

A world is interpretable, and its lessons persist. Branching is cheap to generate and easy to make weightless, so four properties separate a world worth returning to from a generator of plausible pages. A theme is not a label on a story but a pattern the record keeps producing — what a world rewards, exacts, and forgives — readable off recurrence and falsifiable against the events that support it. Rules are temporal: institutions, clocks, permissions, and constraints are adopted at a moment, bind for an interval, erode, and are rewritten by what happens under them, which is what makes a long game mean anything and what the moment cursor is for. Minds keep their own continuity: an actor carries commitments, debts, and a private version of events between appearances, so motive is inferred rather than invented and acting out of character is a defect to explain. And the aspiration is cinematic — place, hour, who is present, what is withheld, what the cut omits — a quality bar the production specs answer to rather than a capability that ships today.

Meridians begins from a limit: no record contains a whole world, and no perspective possesses it. A Domain is therefore maintained but partial: its rules can be inspected, its actions attributed, and its open remainder preserved without being turned into prophecy. The aim is not machine authority, but better plural agency under conditions that can be understood and revisited.

A Domain can be re-entered from several directions: rise to the pattern, descend to the evidence, move across relationships, or travel backward through how the understanding changed. The graph is causal and informational, so different perspectives receive the memory, information, permissions, and tools they can actually reach rather than one omniscient prompt.

At N=1, the engine looks like a personal intelligence instrument. Evidence is weighed against open questions; the Program maintains the Domain; Stories surfaces material movement; the operator tutors the model and owns the Position. That configuration matters commercially because it is useful before a room, league, or World exists. Architecturally it already proves the deeper boundary: machine-maintained context, human judgment, and a history neither has to reconstruct from scratch.

Research adds memory. The Program extracts signal. Exploration prices the futures. Scenario commits a move. Experience prepares the timelines that earned it. The branch preserves consequence. World re-enters that history at a moment and lets it be walked. The result is not another answer but a world capable of continuing—and a history no participant authored alone.

Source material, canonical world, and presentation remain distinct. Reality, history, synthetic events, or licensed canon may seed and later inject material into a Domain. A Stageplay adapts selected state but its blocking, performance, and edit do not become canon merely because they were shown. A World remains its own locus of state and evaluation; it does not become a claim that Meridians predicts or governs the source reality. A World is entered at a chosen moment on a branch and wandered rather than read in order, and nothing said inside it writes canon or advances the branch it was taken from; unlike a prepared novel it generates as it is explored, so its cost is metered like any other live lane. Real-value stakes and licensed operation require their own authority, integrity, and rights boundaries.

The production sequence is sources or canon → maintained Domain → branches explored and priced → the branches that earn it prepared as a visual novel. Exploration is the engine of the catalogue: a Reading cuts a fan of futures from an as-of vantage without hindsight, graded by prior rather than offered as equals, so the possibilities a world is worth spending on are found by search rather than decided in advance. This is what a completely recorded world buys: with rules, cast, stance, and state all typed, a counterfactual is run rather than invented, and two branches differ in ways that can be pointed at. A prepared world does not generate while you read it: text and images are produced once, and reading serves finished assets, so cost per reader is hosting rather than inference and the artifact can be reviewed, fixed, and shipped. Extraction, structured Domains, research cycles, the Program, Studio, Hosted, Stories, Positions, branches, readings, the Exchange, Scenario primitives, MCP, image generation, and the Script scaffold ship today. The dedicated reader interface, budget-bounded exploration, and asset production for promoted branches are specified and not yet built. Stageplay — sprite-led audiovisual production, reusable world assets, and deterministic direction — remains active incubation, not yet a shipped Studio capability. World deployment, persistent simulation, and MMO-scale participation are experimental direction rather than committed roadmap. Adapting a canon requires rights we hold or are granted; performance inside any synthetic world proves behaviour under that declared simulation only.

One engine, read at four distances. A reader who meets the explorable novel on page one and a personal intelligence subscription in the Business Model will suspect two companies wrote this. There is one, and the relationship between its claims is fixed. Everything that follows sits somewhere on this ladder, and nothing on it is a pivot away from the rung below.

The crux is production cost. The visual novel is not a niche because readers dislike it; it is a niche because one branching, illustrated, voiced, internally consistent world costs a studio years, and that cost forces every commercial instinct toward the linear version. A book is a block of text you receive in one order. A visual novel is a place you are inside: what you choose changes what happens to people you have come to care about, and what you failed to look at stays hidden. Meridians exists to automate the production of that artifact from a world that is already maintained — because the state, the cast, the rules, and the consequences already exist as data, the branch does not have to be hand-written to be coherent, and the secret does not have to be planted to be findable. It was in the world the whole time; exploration is what surfaces it. Make the artifact cheap enough to produce and the medium stops being a niche.

The maintained expert and the explorable novel are not competing theses; they are the same record sold at different distances. The expert is the Domain read as analysis while it is still being maintained. The novel is the Domain read as narrative once its branches have been explored and the ones worth having prepared. A Scenario is the same Domain at the moment a commitment is made. Confusing them is easy, and the paper is written to make the difference legible: what changes between the three is the interface and who is paying, never the record underneath.

What this document contains

This is deliberately two documents bound together, and the shorter one carries the argument. The main body is the thesis; the appendices are the technical specification that makes the thesis checkable. Reading only the main body costs you no step of the argument — it costs you the ability to audit it.

The vocabulary, in one place

The paper carries about twenty proper nouns. Each is individually load-bearing and collectively they are a tax on a first read, so they are defined once here rather than discovered in scattered footnotes. Everything else is ordinary English.

The problem is not generation. It is forgetting between answers.

A frontier model can summarise a thousand pages or propose a convincing next move. What it does not naturally preserve is the durable world around the answer: which evidence mattered, what was believed before, why the read changed, what remains uncertain, who could know what, and what the next decision must inherit rather than reconstruct.

People already have more information than they can use. The expensive work is recovering the signal: connecting a new development to the actors, rules, relationships, commitments, and open questions that give it consequence. When that structure disappears between sessions, every return begins with archaeology.

Existing tools solve adjacent pieces. A feed delivers activity. A knowledge base stores material. A chatbot rebuilds an answer from whatever context fits. An agent framework calls tools. A game engine preserves state. None alone keeps a language-native world current, queryable, and accountable across both interpretation and action. The missing object is the world around generation. It must be inspectable enough for a human to understand, structured enough for software to enforce, and open enough for human and autonomous Will to produce a history the engine did not pre-author.

The same problem exists even for one operator following a moving domain. Sources multiply, questions remain open, and every development must be judged against remembered state. None keeps the whole picture — rules, actors, evidence, open questions, prior judgments, and causal history — alive between visits. The personal maintained expert is therefore not a different thesis. It is the smallest useful instance of the same persistent-world problem.

This is an agency-under-consequence problem. Machines can maintain memory, assemble the case, and propose action; they cannot silently own the commitments of the people and agents operating through them. The useful boundary is persistent machine-maintained context with situated, attributable Will.

Meridians holds that boundary with one maintained Domain, inhabited three ways. At N=1 it helps one operator keep a live read without rereading the world from scratch. **Scenario** lets that operator or a trusted group commit a consequential move against the same remembered state. **Experience** prepares the timelines that earn it as a novel to read. **World** re-enters that history at a chosen moment and is wandered rather than read in order. Three mediums, one Domain, one record of what each move made true.

Why now: frontier models can interpret large language-native worlds, retrieval can reopen the right evidence, MCP can expose bounded capabilities, and inference is cheap enough to revisit situated context on a cadence. The opportunity is no longer a better isolated answer. It is remembered context, selective attention, and coherent continuation.

From a cold start to a live first read

The engine is the argument of this paper; the product is the practice a person can begin without learning the engine. Meridians should not open by asking for a paradigm, breadth, cadence, source catalog, or graph. It asks what the person is trying to move, shows what it understood, grounds a focused expert in current evidence, and brings the first useful movement into the same surface they will use tomorrow.

The organising object is a constellation: a private orientation to the person at the centre, with external domain experts orbiting it because each bears on a real goal. The first orbit is deliberately small. Depth is earned progressively; the product does not demand a model of someone’s whole life before it has proved useful on one decision.

That is one coherent handoff, not five tools. Research does not end in a research console; it ends in a Story. A Reading does not end in a probability display; it grounds a Position. The Position does not move the person automatically; it keeps a live read, and the person judges how it moved.

The interface keeps the number of behaviours small: type or tap the same contextual microphone, review one focused consequence, then continue from Home. Long work minimises into one persistent dock and returns to the same Story or review surface when ready. The machinery changes by task; the way a person speaks, judges, and picks up the thread does not.

From first value to a compounding practice

The product becomes defensible after the first session: the expert keeps watch, the user’s corrections alter later behaviour, and the Position keeps the track of how the read moved. Voice makes that tutoring richer; Hosted makes the same Program persistent. A public network is a later consequence of users loving those private artifacts, not a prerequisite for them.

The useful instrument exists now — a person can gather research into a Domain, inspect its Graph, follow Stories, keep a self-updating Position, and explore a move through Scenario. Stageplay develops the deeper Episode form for roleplay and audience engagement. World is the experimental sandbox for mature branches, not the prerequisite for product value. The roadmap succeeds when each layer is satisfying at its own scale, not when every horizon is named as if it already exists.

The world remembers more so the person can attend to less. Meridians keeps a Domain recoverable across evidence, structure, provenance, and time, then gives the immediate horizon more detail than the distant past. Total recall does not mean every token is equally present, every source deserves attention, or the model cannot be wrong. It means the world remains re-enterable: load-bearing detail can be found again, and the path by which the read changed has not vanished.

Memory is stewardship, not omniscience. Three kinds of memory make that possible without pretending the retained record is the whole territory. Archival memory keeps sources, scenes, decisions, and provenance available for inspection. Structural memory keeps actors, rules, relationships, questions, and causal history coherent in the Domain. Working memory brings forward the recent and load-bearing material needed for the present question while faithful snapshots stand in for distant history.

A flat archive answers where is the document? A Domain supports harder movements: rise to the pattern, descend to the evidence, move across relationships, or travel backward through how the understanding changed. Querying is one entrance into that space; graphs, timelines, outlines, maps, and situated perspectives are others.

Recall is not exposure. Research can gather broadly while Opinion stays quiet until something materially moves the read. A successful run may surface nothing. The retained corpus remains available for deep comprehension and interrogation without turning the operator's attention into a feed that must be cleared.

Any live question can become a Position traced through causal, variable, and temporal reasoning. The operator can ask not only what does the corpus say? but what changed, what does it affect, which assumption carries the conclusion, what evidence would reverse it, and what could happen next? The answer inherits the maintained world instead of rebuilding it from a convenient slice.

Meridians is therefore more than search over documents. It is a practice instrument for building judgment under consequence: the machine maintains memory and assembles the case; the operator decides what deserves belief, attention, and action.

We built a representation for expertise and called it a Domain, because that is where the problem first made sense. An expert's belief is never a bare fact — it is a Position, the evidence behind it, its causal history, and its bearing on an open question. That is what a world model can keep coherent: a belief should not jump without the reasoning and continuity that justify the move. The same machinery can hold a research field, a fictional setting, or a private practice world without claiming that any of them predicts reality.

It works because text is how both humans and models reason, so a domain is a legible base component for any living domain: a run of key developments, the actors they move, and the open questions still pulling. A market has that shape; so does a conflict, a league, a screenplay — which is why one component reads a domain as cleanly as a script. And because a domain decomposes reality into actors, rules, and open questions, the model it produces is human-readable by construction — the opposite of a black-box embedding or an opaque feed. Those three axes are the same three forces the engine measures: System (the rules), World (the actors), Fate (the open questions). Every domain has a signature in how it weights them.

Fiction is where this proves out cleanest, and it earns exactly one sentence here: a finished novel is a world whose shape readers already agree on, so it is the cleanest place to check that the math reads coherence before pointing the same engine at a domain you actually follow (see Validation). The machinery itself — the forces, the stance math, the reasoning graphs, the memory — is laid out in Appendix A.

The first useful configuration is one operator, one maintained Domain, and one Program. It is the N=1 form of the larger engine: most world activity is delegated, one human camera receives what materially moved, and human Will enters selectively through corrections and Positions. Research reads, Opinion filters movement, Merge folds mature evidence into canon, and Position forms a live read. Each pass inherits the state left by the last. This is not a separate personal-intelligence product bolted in front of World; it is the smallest world in which persistence, context, judgment, and consequence already matter.

It keeps reading after you close the tab

On a cadence suited to the domain — hourly for a breaking beat, weekly for a literature — Watch revisits trusted sources and the questions already in play, whether or not anyone is looking. Opinion distinguishes activity from movement: a new article is not important merely because it is new. A Story earns attention when evidence changes a position, re-prices a read, resolves a question, or exposes a gap in the model. Quiet is a valid result — nothing surfaced means nothing you believe has changed, which is information, not failure. This is what converts a model you built once into a read that stays true.

It folds evidence into canon — on its own

Merge is where the read becomes durable. On the domain’s cadence it folds every mature Stream and every ready Note into canon in one pass — autonomous and always-armed, never a fold to approve. Your control moves earlier and coarser: set which inputs it may touch and how often, designate a question’s outcome before the window, or merge now — and every fold is versioned and reversible. This is the line the whole system is built around: delegate the maintenance, keep the judgment. You still write on the model — a correction changes what a source is trusted for, how a question is framed, what the expert watches next — and it persists, so the next cycle starts from your standard.

On a personal domain the beat runs the other way. A Reminder arrives as one Story card asking a single question — what changed, and did anything you decided turn out differently? It nudges; it does not write for you. Only your answer becomes a Note, and an ignored prompt leaves no trace. Habit systems fail because they demand both the prompt and the answer, then punish the gap; a Reminder supplies the prompt and drops the punishment. What accumulates is not entries but a model, so reflection compounds instead of restarting.

It turns understanding into positions

Position turns a reading into a situated commitment: a question, viable futures, and the causal reasoning that grounds them. In a practice world, that commitment can be played forward against declared rules, information conditions, and other agency. Research keeps the world current; Scenario makes consequence legible. A broken read is a lesson in the chain, not a verdict on the person. Every revision remains inspectable, attributable, and grounded in the evidence or canon that moved it.

The human loop is a learning-and-foresight loop

The machine runs Research → Opinion → Merge → Position. The person experiences orient → judge → refine → learn → watch — and lived from the inside that is a learning-and-foresight loop: you consume what moved, explore the model behind it, learn as its read sharpens, tutor it toward your judgment, and project — point a question at the world and watch its read move. Most cycles require only orientation. Stories keeps that interaction finite and is where you judge how the read moved; the studio holds the depth. Together they let the machine work continuously without doing the living for you — so what compounds is not only the expert, but your own grasp of the domain and your progress toward what you set out to do.

The Program is what ships: the first commercial and practical configuration of the engine, gathering sources and maintaining a Domain for analysis. Scenario opens light solo or asynchronous group decisions over it. Stageplay is the active narrative-production proof, creating deeper Episodes around the same branch substrate. World remains a later experimental sandbox.

This is the section the rest of the paper depends on, and it is the one with the least evidence behind it. The engine explains how a world is maintained; the mediums explain how it is entered; the business explains who pays. None of them explain why anyone comes back. The training loop is the answer, and it is the same answer at every rung of the hierarchy: the reason to return is that the last return changed you, and the world kept the receipt. A Director returns to a maintained expert because the correction they made last week is visible in this week's read. A reader returns to a prepared novel because the route they did not take is a different story and the secret they walked past is still in the world. A seat returns to a World because the consequence of its last commitment is now the situation it inhabits. One mechanism, three surfaces — and if it does not hold, Meridians is a very well-built way to produce artifacts that people consume once.

The primary loop is reading, choosing, and imagining, and it runs inside the visual novel. Everything else in this paper is machinery for producing the artifact that loop runs on. A sufficiently deep novel is not a story that has been consumed once and is now spent: it is a place with more in it than one route can reach, so the loop is read a scene → choose under partial information → imagine the world the other choice would have made → return and find out. That third beat is the one conventional interactive fiction cannot pay off, because the alternative was never written. Here the alternative is a branch of the same world with the same rules and the same cast, so the imagining is not idle — it is a hypothesis the artifact can actually answer.

This is what makes the VN a repeatable experience rather than a long one. A novel produced from a maintained world carries more state than any single route surfaces: relationships that only matter from one perspective, evidence that is only legible if you already looked somewhere else, consequences that resolve three scenes after the decision that caused them, and secrets that were in the world before anyone thought to look for them. Given enough production budget, a reader can keep extracting from the same artifact — a second route, a different seat, a re-read that now means something else — and keep getting a different experience out of it. Depth is what converts a finished artifact into a returnable one, and depth is a production-cost problem, which is exactly the problem the engine exists to solve.

The other loops in this system are auxiliary, and naming them that way is deliberate. The Program's maintenance cycle keeps the world worth reading. The Director's tutoring loop keeps its judgment honest. The Scenario table makes a decision resolvable, and a World makes a moment wanderable. Each is real and each has its own return, but none of them is the mainstream consumable — they are how the consumable is produced, sharpened, and extended. If a design choice makes an auxiliary loop stronger at the cost of the reading experience, it is the wrong choice.

A world can remember and still fail to make the player better. Extraction creates substantial upfront utility, and persistence keeps that value from evaporating. Neither alone creates replayability. A coherent practice must reward returning with greater ability: sharper comprehension, better judgment under uncertainty, stronger coordination, and a more truthful relationship with consequence.

The pieces exist, but the loop does not yet exist as one product experience. The Program is a real recurring machine activity loop that maintains a live read; it is not yet player progression. Direct Scenario already supplies the inner play loop: Brief → Prepare → Commit → Consequence. Chat supports repeated inquiry but is too fragile and low-consequence to carry progression by itself. Stageplay and Episode are developing immersion, explanation, and strategic puzzles. The open work is joining them so every return develops the participant as well as the branch.

The debrief is the missing hinge. Without it, repeated scenes create content and history but weak learning. With it, branch comparison, Position movement, calibration, active recall, and causal inspection can show what the participant anticipated, what they missed, what another seat knew, and what should change before the next attempt.

A complete loop should leave two legible records: what changed in the world, and what changed in the participant's ability to notice, judge, coordinate, create, or act. The second record is not a cosmic score or a verdict on the person. It is evidence of practice inside a declared Domain, task, perspective, and interval.

What this is not: a level, a streak, or a number that goes up. Conventional progression systems solve the retention problem by making the counter, rather than the capability, the thing that accumulates — which is why they survive the loss of the underlying game and why they teach nothing. The record this loop produces is different in kind: it is a history of commitments made under stated information, the consequences those commitments actually had, and the gap between what the participant expected and what the world did. That history is legible without being scored. It supports the sentence “here is a signal I learned to notice and here is where I first missed it”, and it refuses the sentence “I am level 34”. If a numerical progression layer is ever added, it earns its place by summarising that history — never by replacing it.

Consequential RPG mechanics may give that practice teeth: roles, relationships, resources, permissions, tools, reputations, quests, economies, escalating constraints, perspective rotation, branch replay, or spaced challenges. None is the universal answer yet. A mechanic earns its place only when it produces useful decisions, informative consequences, and a reasoned debrief—not because MMOs conventionally contain XP.

This training loop is a working product hypothesis, not a shipped capability claim. The next proof is deliberately small: connect Consequence → Debrief → Adapt → next Brief inside repeatable Scenario or Episode cycles that yield real comprehension or decision utility. A persistent World and MMO-scale society come later, if those smaller loops are satisfying enough to deserve continuity.

The Harry Potter test

Test 1 of the program, and the only one that has been run. Before you trust the math on your own world, watch it read a story you already know by heart. The activity curve below was computed entirely from structural deltas extracted from Harry Potter and the Sorcerer's Stone — no prose scored, no scenes hand-ranked. The annotations land where they do because the formulas read the book deterministically. Orange above zero: scenes where fate and world move together. Light blue below: the quieter stretches that set up the next peak. What this establishes is bounded and worth stating precisely: the representation is sensitive to at least one real form of narrative structure, in at least one finished work. It does not establish that the same math projects an open world forward, that it generalises past this corpus, or that a second extraction run would draw the same curve. Those are the next five tests, and they are listed below rather than assumed.

Peaks and valleys

The peaks line up with scenes where HP's three channels fire together: Hagrid's reveal, the Gringotts vault, the first Hogwarts lessons, the Flamel hunt, the Quirrell-Voldemort confrontation. Threads commit, entities transform, and the world's rules snap into focus at once — not chosen by taste, but emergent from the deltas.

The valleys are equally load-bearing. The Dursleys' opening normalcy, the three-headed-dog aftermath, the winter stretch before the Forbidden Forest, the denouement — none resolve a thread. They are turning points: tension is seeded, a boundary crossed, a character glimpses the unknown. They contribute less to each force, so the curve dips; the energy they store is what earns the next peak.

Peaks are where the story commits; valleys are where it launches. The rhythm between them is the domain's pulse, and both sides of the zero line carry weight.

What the result means — and doesn't

The core claim is narrow and testable: deterministic formulas, run over structural deltas, recover the dramatic shape of a story. The LLM extracts deltas at low temperature and the math downstream of it is fully deterministic, so the same deltas always yield the same curve. Informal repeat runs have held their rankings, but that is a spot check rather than a result: the pre-registered version is Test 2 below, and until it is run the stability claim stays informal.

The recovery test is honest because the engine didn't write the book. The same formulas also drive generation — the measurement is the objective function — so once a score is what generation optimises toward, “the output scores well” proves nothing (Goodhart's law, cited below). Reading Sorcerer's Stone back is clean precisely because it's post-hoc on a text we never touched. The generative side earns no such free pass, and we don't grant one.

Coherent text has measurable structure. Recovering Harry Potter's shape from delta arithmetic extends a small empirical tradition — emotional-arc and narrative-shape recovery from text^{Reagan et al. 2016Boyd et al. 2020} — by reading not just sentiment but the three structural force-fields beneath it.

The forces don't care whether the world is invented. System counts rules and their connectivity, World counts entity-state changes, Fate counts information gain on open questions. A novel, a campaign log, and a social simulation all accumulate those same three things, and the same math reads them. The domain case is shown; the cross-world reach is the working hypothesis the rest of the engine is built against.

Reproducible is not the same as valid. The novel proves the math is well-formed; it doesn't prove the readings mean what we hope. Determinism lives downstream of the LLM's extraction — the interpretive judgement isn't removed, only relocated into which deltas get emitted. And reading a finished, designed artifact backward is gentler than projecting an open world forward.

Reading a known story backward is the start, not the finish. Whether the same math gives legible readings of an unwritten world is the next thing to test. The ground is chosen: declared scenario worlds, run under stable rules and controlled information conditions, replayed by human and agent cohorts, and scored against a stated task. Each run preserves the world version, policy, and result, so a measure remains reproducible rather than becoming a remembered story about success.

The benchmark program

A single reconstruction is an anecdote with a chart attached. What turns it into evidence is a program: an ordered set of tests, each with a stated pass condition and a stated failure, run in an order where a later test only matters if the earlier ones hold. Test 1 has been run. Tests 2 through 6 are specified and unrun, and the paper does not lean on results it does not have.

The order is not arbitrary. Test 2 gates everything after it: if repeated extraction of the same text yields materially different curves, then Test 1 measured a sampling run rather than a novel, and Tests 3 through 6 are measuring noise with more steps. Test 5 gates the interpretation: a metric that stays high when continuity is deliberately broken is describing text volume, not structure. Test 6 is the only one that touches the forward claim the product actually rests on, and it is deliberately last, because there is no point predicting an open world with an instrument that cannot yet read a closed one twice the same way.

What would make us stop. If Test 2 fails, the measurement layer is rebuilt rather than reported — the forces would be recording the model's mood, not the world's shape. If Test 5 fails, the metrics are demoted from evidence to interface: still useful for showing an author where a world is thin, no longer admissible as a claim about narrative coherence. If Test 6 fails while 2 through 5 pass, the honest reading is that Meridians measures worlds well and predicts them badly — which leaves the maintained expert and the explorable novel intact and retires the forecasting language entirely. None of these outcomes are hypothetical concessions; each has a section of this paper it would delete.

An always-on expert creates a new interface problem: the machine works while nobody is looking, but a human still has to understand, trust, and occasionally redirect that work. A notification is too thin; the desktop studio is too deep for every small intervention. Stories is that middle layer.

Inspired by the focused rhythm of Instagram Stories, each Story is one discrete card projected from canonical machine activity. It says what happened, why it matters, and how the read moved — not just an update to read, a judgment to make. The same card supports consumption and manipulation: inspect the evidence, accept the update, correct the prior, reject weak reasoning, or defer the decision. The goal is not engagement. It is to make high-leverage human judgment small enough to contribute well from a phone.

Meridians borrows the focal card, finite progress, and clear end — not engagement ranking or endless continuation. Order follows consequence, salience, and time. Success is caught up: what runs next is visible and the person can leave.

The reason to borrow the format is that it makes tutoring cheap. Monitoring produces the moment worth attention; acting on it used to mean opening a studio and writing something considered. A card collapses that to seconds — the difference between a correction that happens and one that doesn't. The surface that looks like consumption is the growth mechanism. Reminders run it in reverse: the machine brings a question you agreed to be asked, and your answer becomes a Note the domain keeps. One surface, both directions.

Human-in-the-loop is a boundary, not a queue

Approve everything and the user rubber-stamps; approve nothing and the model makes consequential choices alone. Research can run within trusted bounds. Stories escalates contested evidence, durable Tutor changes, and new Position re-prices. Actions stage intent for the next eligible run, remaining editable until reservation. Trust stays granular: Research may be autonomous while Tutor changes and Position re-prices stay reviewed — the machine keeps the read, but you judge it.

A Story is not a second source of truth. The Hosted Fly Machine or desktop daemon owns the record and keeps running with no client attached. Cards reference that record; reading and dismissing affect delivery state only; model-changing actions dispatch typed, authorized, attributed commands and wait for acknowledgement. Reconnects replay from a cursor and collapse duplicate machine events into one card.

The likely failure is not that people cannot use Stories. It is that they skim, defer, or rubber-stamp when the queue becomes work — while an empty queue makes a quiet expert feel broken. So the bar Stories is held to stays narrow: the first evidence brief, the first grounded Position read/re-price, and one Tutor correction; four actions — inspect, accept, correct, defer. Ongoing Monitor upkeep surfaces only when it is material. Stories earns its place when people understand why a card matters, reach a judgment without later reversal, and can point to something the expert now does differently because they taught it. Opens and streaks do not count.

The technical thesis is only half the risk. Meridians also asks people to form a new habit: maintain a model, teach it judgment, and judge the live read it keeps for them. The following are behavioral hypotheses, not established facts.

The likely user failures

• 1.The first loop fragments. A new user meets setup, research, Stories, and reasoning as separate tools and leaves before one question becomes a grounded expert and a live read.
• 2.It feels generic before it compounds. Early output is easiest to compare with a feed or chatbot. If the first run does not reveal a material movement or reflect the user's domain, there is no reason to return.
• 3.Quiet feels broken. A selective expert should sometimes have nothing to report, but people may read silence as inactivity. Health and the next run must stay visible without inventing updates.
• 4.The human loop becomes review work. Too many approvals produce deferral, rubber-stamping, or abandonment. The expert must escalate consequential judgment, not every machine action.
• 5.Tutoring has no visible echo. People will stop correcting a model if they cannot see the lesson change later research, reasoning, or language. Repeated corrections are a failure signal.
• 6.Being wrong triggers avoidance. A verified expert is graded in the open, and its operator feels every mark. The design separates the two honestly: the Position — the reasoning — is never marked true or false, so a broken thesis reads as a legible lesson in the chain rather than a verdict on the person; the position takes the loss. Records stay private by default, and postmortems teach rather than punish. Verification that shames its operator gets abandoned, which is a worse outcome than being wrong.
• 7.Confidence outruns evidence. A coherent, inspectable model can still invite automation bias. Uncertainty, source limits, disagreement, and durable human overrides must remain visible.
• 8.The world progresses but the player does not. Repeated scenes add branch history without a debrief, an adapted challenge, or evidence that the participant is becoming more capable. Novelty substitutes for practice.

Evidence gates

• 1.The first loop completes. A new user can move from one question to a grounded expert, understand a material Story, inspect the causal, variable, and temporal basis of a Position, and judge one re-price without operating the underlying research desk.
• 2.First useful movement. A new user can identify something material the expert found, clarified, or connected better than their existing routine.
• 3.Signal earns attention. Useful-card rate, dismissals, mutes, and queue age show that the loop is selective. A caught-up state builds trust instead of anxiety.
• 4.Tutoring changes future behavior. Corrections visibly alter later output, and the same correction is requested less often.
• 5.Accountability improves decisions. People stake resolvable calls, revisit misses, and outperform a stated baseline — then point to a decision they changed because the model moved.
• 6.Trust expands without regret. Users delegate Research before Tutor or Project, reverse few autonomous actions, and still describe the expert as theirs at month six.
• 7.A repeatable practice improves ability. Across several bounded cycles, a participant can point to a signal they learned to notice, a causal mistake they stopped repeating, a perspective they can now inhabit, or a decision they can explain and calibrate better.
• 8.A network is requested, not presumed. The Exchange ships the free exchange; retained users maintain experts, publish or share them, and ask to discover others before the paid public network or creator commerce becomes a product priority.

Underneath these behaviors, extraction, source weighting, and calibration still have to beat clear baselines. The product is real only when the model is technically better, visibly shaped by its Director, and useful enough to change a decision.

The argument, in four links

The business case is a chain, and it is only as strong as its first link. Each link below has to hold before the next one is worth discussing, and the paper is ordered so that a sceptical reader can stop at the first one they do not believe.

Only the first two links are load-bearing for the company to exist. Links three and four are optionality, and the Network Scenario later in this section is explicitly a model of link four under assumed dials — not a forecast, and not part of the case for the product.

The operator pays for the instrument

The base business has to work at one Director with one private expert. The Director pays for a maintained model that keeps watch and improves their decisions; no audience, public profile, or marketplace is required for the product to earn its price.

There are two first-class weekly subscriptions. License is $3.99/week: the same daemon and canonical record run on the Director’s computer, and provider usage is billed through their own keys. Hosted is $5.99/week: Meridians runs an isolated, always-on machine and includes the AI and research usage. Either product grants Director access; a person may hold both.

Two products, two margin shapes

License has a mostly flat cost base because inference, embeddings, images, and research are BYOK. Hosted takes on the machine and provider bill, so its margin moves with the Director’s workload. At the current price, the modeled post-payment headroom is about $21.16 per month; that makes metering, a fair included allowance, and an explicit overage or pause policy part of the product, not an implementation footnote.

The detailed workload assumptions, provider price references, sensitivity cases, and break-even analysis live in the maintained unit-economics model. This paper keeps the commercial promise legible instead of freezing volatile model prices into marketing copy.

Where the Hosted number actually breaks

The modelled headroom on Hosted is an average, and averages are the wrong instrument for a workload with a long tail. Provider cost per Director is driven by research cadence, corpus size, image generation, and — most of all — by how much of a Domain gets re-read. A small number of Directors running large corpora on aggressive cadences can consume the margin of a large number of light ones, and the price does not currently distinguish them.

Three specific exposures follow, and each has a control rather than a hope attached. Concentration: a heavy tail is priced by a metered allowance with an explicit overage-or-pause policy, which means the allowance has to be visible in the product rather than buried in terms. Provider dependency: the cost base is set by parties we do not control, so the runtime keeps the provider boundary swappable and the record portable, and License exists partly so a provider shock has a destination. Workload drift: a feature that quietly increases re-reads is a price change, so cost-lane accounting is a build-time requirement rather than a finance exercise. The honest position is that Hosted margin is an observation we do not have enough of yet, and the number in the table above should be read as a design target that the metering exists to defend.

Why the buyer pays

Querying an LLM is everyday value; a self-updating expert that keeps a live read is the durable value. Meridians re-reads its sources, reports what materially changed, carries the Director’s corrections forward, and keeps the history of how a Position re-priced. What compounds is the structured evolution of understanding—not a chat transcript or a vector store anyone can rebuild from one crawl.

The conversion event is therefore not a clever first answer. It is the moment the Director sees that a correction persisted, a read moved for an inspectable reason, or the machine noticed a consequential change before they rebuilt the context themselves.

A business at N = 1; network upside later

Operator subscriptions are the floor. If retained Directors later publish experts that attract a paying audience, marketplace fees and rev-share can become an additional rail rather than a rescue for weak individual value. The conditional network case appears in the Network Scenario.

The commercial claim is still unproven. It moves only when retention, workload, and cost evidence do. The risks and gates that must clear are set out plainly in What has to be true.

The product is personal. This section is where it goes later — when several people grow one domain together. We keep the team pricing in the Business Model for it, but the focus now is the individual.

A shared model is many domain artifacts, owned by many people, composed into one. Because every artifact speaks the same uniform contract — the three forces, query, the knowledge tree — one person's can subscribe to, query, or compose with another's. The same engine that runs your personal domains reconciles a room's into one multi-focal model each member still owns their corner of: a writers' room growing one shared domain, or the teams of a business each maintaining the living model of what they run.

The writers' room is the native shape. Each member carries a different read — who a character really is, where the arc should bend, what a faction would do — and Meridians doesn't flatten those reads to a lowest common denominator. Each member's private chat is a tributary that flows through extraction into the owner's substrate, and the owner governs what gets merged into canon. Divergence is preserved, not averaged away; a contested call stays visible until the room reconciles it. Merge is the room turning its takes into canon — and the owner's substrate surfaces patterns no single writer could track across every stream.

Access is graded, and trust climbs with it. A Viewer watches but can't contribute; a Contributor keeps a private chat going and feeds the tributary; a Manager helps govern merges; the Director owns the machine, the data, and answers for the whole. Custody sits with the Director, who runs the substrate on a centralised, hosted Meridians built for the team while members join by guest pass — the hosted instance supplying the collaboration, amenities, and support a room needs.

This stays a bet until real rooms exist. The architecture already supports it — the tributary model works at N=1 and scales to N>1 without a rewrite — but whether creators gather to grow a shared domain instead of staying solo is unproven. So it's a future chapter, not the pitch: solo is the product that works today, and the room is the upside the same architecture reaches for.

Meridians does not require the paid network to be useful. A private expert earns its place by maintaining one person's understanding. The Exchange ships the free exchange today — publish an expert, browse the shelf, preview its provenance and maintenance cost, fork it with real lineage, review an upstream update, or share a private, grant-scoped Bundle with named Directors — and the same artifacts form a network without changing the core product.

Where this points: a library of practice worlds. Each published world carries its canon, lineage, rules, information conditions, and the kinds of practice it supports, so its use remains legible: a follower count says people watched; a world record shows what can be entered, varied, replayed, or evaluated. “Battle-tested” means the world has been played and inspected under declared conditions—not that it predicts reality or ranks its participants. The Exchange grows a shared library of worlds and forks, not a universal leaderboard.

Comparison still requires care. A maintained Position reads differently depending on the question and the signals it watches, so any listing should surface shared questions and the depth of the read-history rather than reduce an expert to a single number. Until those safeguards and enough maintained Positions exist, the record is evidence about an expert to inspect, not a universal league table.

The paid public network — a public browsing landing, ranking, and creator rev-share on top of the shipped exchange — is a later consequence, not the opening proposition: strong public experts become useful starting points for other people — a configured setup to fork and make their own, not just a page to read, since domains are the atomic unit and mix and match into a setup that fits — while private experts remain owned, local, and complete products in themselves. Commerce follows a healthy free exchange, not the other way around.

Meridians does not need a marketplace to be useful or a viable product. The operator pays for an expert that improves their own decisions. The scenario below describes optional upside if some experts are later published, earn audiences, and develop comparable maintained Positions. It is not the product thesis.

The optional distribution loop

If a public network earns trust, distribution could form a second loop:

• Public work can carry its own evidence. A forwarded newsletter issue is an ad; a public, maintained Position — a read re-pricing in the open as evidence lands, its read-history on the record — is proof no cold pitch can fake.
• Some followers subscribe — becoming the operator’s paying audience, and our rev-share.
• Some subscribers spin up their own expert. Watching a model compound is the best possible ad for making one; a new operator arrives already carrying their own followers — and can jumpstart by forking a published setup rather than starting cold, mixing and matching Domains into a configuration that fits, then customising the schedule.
• And it can sharpen itself: a tutored expert builds a deeper maintained Position → surfaces higher in the exchange → attracts more subscribers → more rev-share. Depth and distribution are the same loop — the thing that makes an expert good is the thing that makes it spread.

This loop only matters after the instrument retains users on its own. If it does, every operator may bring an audience and every audience may seed new operators. In that case platform revenue could scale super-linearly: MRR ≈ operators × (license + our cut of a growing audience), and both terms climb together.

The trajectory (scenario dials, not promises)

The per-operator economics are the knowns; the growth, conversion, churn, and audience-ramp are the dials. Three settings of those dials, projected 36 months (exit ARR):

Read the table below as an arithmetic exercise, not as evidence. Every figure in it is an output of assumptions chosen by us: the operator counts are assumed, the subscriber ramp is assumed, and the churn is assumed. Two columns deserve particular suspicion. The margin figures approach the flat-cost License case and would not survive a Hosted-heavy mix at the workloads described earlier. The LTV/CAC figures divide a modelled lifetime by an acquisition cost we have never paid, because nothing has been acquired yet; a ratio with an assumed denominator is a statement about the spreadsheet, not the market. The reason the table stays in the paper is that the shape of the sensitivity is informative — it shows that the spread between outcomes is distribution, not product. The reason it is placed here, after the case has already been made at N = 1, is that none of it is load-bearing.

The spread between cases is almost entirely how well the optional network loop turns — activation, the subscriber→operator loop, and retention. Even the conservative dial clears a real business; the gap to the others is not a different product, it is a different distribution outcome. (These are the model’s outputs under explicit assumptions — a bet on the loop, not a commitment. Run npm run projection.)

Why margins hold as it scales

The two products scale differently. License is BYOK, so its provider cost stays off the platform P&L while the shared control-plane floor amortises. Hosted includes usage, so its margin depends on workload mix, allowance design, and provider efficiency; scale improves purchasing and fixed-cost allocation but does not make inference free. The projection model must therefore keep product mix and Hosted provider COGS explicit instead of applying one near-zero-cost margin to every operator.

It works at every size

The stack degrades gracefully to N = 1: the studio is a personal instrument with zero audience, Stories works for a single operator, and a newsletter only needs to exist once there is someone to send to. So growth is never a precondition — it is upside. The instrument supplies the floor; a network may raise the ceiling.

Strip everything back and one identity is left. Meridians is a studio of fate: worlds recorded completely enough to be run forward, their parallel outcomes searched rather than asserted, and the timelines worth having handed back as something you can enter. Everything in this paper — the maintained record, the Program on a clock, the causal graph, branches, Scenario, and the MCP surface — becomes substrate for that sentence. The hard problem is keeping plural action checkably legible: what rules applied, what each perspective could know, which tool carried its Will, how information travelled, and what Fate remains open after the turn.

What we are really building is the infrastructure for plural Will. Programmable System, situated World, open Fate, and typed tools let a Domain support more than one generated scene. Together they leave a durable record of what the world became. Research and the Program make the Domain useful before play: current sources become maintained, inspectable understanding. On top of it sit three peer mediums rather than a ladder — a Scenario where a move is committed, an Experience prepared once and read, and a World entered at a moment in its own history and wandered. Stageplay lets one Director use reusable assets and situated cameras to embody authored Will or wrap a Scenario choice without changing canon; the reader interface and the World runtime are specified, not shipped.

The parts are copyable and the models will keep improving. Neither replaces what you or every other participant. What no stronger model can generate cold is the particular history a world acquired through many perspectives acting over time.

What compounds alongside the instrument is you — and every other human or autonomous agent invited into play. Will remains open until a seat chooses; MCP makes that choice concrete and attributable without pretending the engine authored it.

Taken whole, this is not a research tool with extra tabs — it is a world capable of continuing. The Domain can be extracted once and played many ways: Scenarios at branch tips; zero, one, or many short or long Worlds from any preserved state; different presets, information regimes, economies, and metrics. Branches preserve possible states while Worlds become coexisting lived worlds. The result is a history that is situated, attributable, and kept — not because it runs without rest, but because its state and consequence survive the turn. It may sleep, pause, end, migrate, or grow while its lineage remains

And the endpoint the whole instrument bends toward is coherent continuation under many wills . The ambition is not infinite generated content. It is a world whose rules can be programmed, whose information has geography, whose frontier can expand, and whose history remains understandable after no single participant controls it.

Gather what matters. Keep the world coherent. Attend to the signal. Play the critical move.

Meridians — the architecture in this paper, and the system that implements it — was designed and built by jasonyu0100. The three-layer model, the Program that keeps it current, the causal graphs, the stance math, the single-writer record, and the discipline that nothing is called live until it is — all of it is one point of view, held end to end.

The ownership split runs through the codebase the same way it runs through the product. The architecture is authored: every core contract — the reducer, the access model, the Program pipeline, the forces, the temporal context, the engine and its prompts, the canonical record — carries a single author's hand and is marked as such. The domain content is not: what each expert comes to believe is produced by the Program loop at runtime, from the sources and corrections an operator supplies. The machine maintains; the author configures, shapes, and stands behind the design.

Written and engineered by jasonyu0100. Meridians is his work.

Five nested layers

A domain is only editable if it has a structure to edit. A blob of prose can’t be branched, queried, or stress-tested, so before anything is played the engine decomposes a long-form domain (a series, a film, a game world) into five nested layers, from the whole down to a single sentence — each a handle you can grab. (Harry Potter runs throughout as the test fixture, so every reader can check the engine’s reading against a domain they know.)

Structure (scenes with deltas) stays separate from prose (beats and propositions) — rework a story’s shape without touching its words, or rewrite the words without disturbing the shape. The same split lets a live session at the table count as a scene: cards played become structural moves, the negotiation log becomes the prose.

Layer definitions

Separation of concerns

Each layer can move without breaking the ones above it. Forces read off deltas, never the prose; revision edits beats without disturbing scene structure. Every layer is independently auditable — what makes a domain safe to keep reworking.

The three forces are the measurable spine of a story's shape — the answer to “is this arc actually moving?” Every scene either deepens the rules, changes the people, or presses on an open question. Score those three and you see, scene by scene, where a story builds, where it stalls, and which thread is primed to pay off — before a reader ever feels it.

Three fields, one per kind of change. Abstract: the rules. Physical: the entities acting under them. Possibility: what could still happen. System, World, and Fate score each one.

Fate is possibility, not probability: what could happen, not what will. Different work weights the fields differently — a lore-heavy world grows mostly System, an ensemble drama mostly World, a tight plot mostly Fate. The same instrument can make those different signatures legible without claiming to predict what happens outside the world.

The three forces

Activity

A work reveals in two kinds: encyclopedic (World, System) and possibility (Fate). Summed on a common scale, they give a single per-scene reading — the activity curve $A_i$, the total rate at which the revelation machine is working.

Each force is first rank→Gaussian normalised: $z_i={\Phi }^{-1}({\text{rank}}_i/(N+1))$, placing all three on a common axis independent of natural units. The weighted sum expresses activity level in standard deviations from the work's own mean.

The weights are the work's signature. Recovered by principal-component analysis on the three normalised force curves. PC1 — the direction of maximum variance in $(F,W,S)$ space — identifies the axis the work moves along most; its absolute loadings, renormalised to the unit simplex, give the weights. The signature is a property of the text, recovered from its variance.

Reading the curve is reading the pacing. A peak ($A_i\gg 0$) is where the forces fire together in the work's own vocabulary — a climax, a turn, a revelation; a valley ($A_i\ll 0$) is a quiet stretch setting up what follows — or a dead spot, if it's in the wrong place. Peaks and valleys map rhythm, not merit, but rhythm is exactly what tells you whether a draft drags.

Influence over time

The activity curve sums the forces into one line. To see which threads, entities, or rules do the pulling, the room reads the Influence alluvial.

Pick a source (Fate, World, System, Themes, or Streams). Each band is one container — a question, an entity, a rule, a thematic proposition — and its width at every scene-bucket equals the movement or attention it drew. Bands enter, swell, recede, recur, and sometimes resolve.

Type mode re-groups force logs by kind; for Themes, it compares broad Types or their individual Theme propositions using the same attributed evidence.

The literal picture of how things influence one another over a run — and the substrate for the second reading: whether the room has been here before (Prior Knowledge & Foresight).

Themes are the ideas a world keeps testing. Fate, World, and System describe the substrate that makes a world coherent enough to simulate: open questions, actors and state, rules and constraints. Theme is their qualitative complement. It deconstructs the patterns those forces produce, distinguishes a durable proposition from a recurring topic, and explains how each scene changes the proposition without turning interpretation into an untraceable label.

Automatic at the scene boundary

Every newly extracted or generated scene emits Theme evidence in the same structural pass that builds its World, System, and Fate deltas. The Domain Wizard establishes the first Theme Tree; extraction reconciles equivalent propositions across parallel chunks; later Arc generation reuses stable identities and opens new thematic ground only when the story earns it.

The Scene is the attribution boundary. It records which Theme moved, what role the scene played, the precise rationale, and which canonical entities, rules, or open questions carried the movement. Arc analysis is then derived from those signals rather than guessed in a detached summary pass; a structural Scene revision carries the same thematic contract.

Types organise; Themes interpret

A Theme Type says love or power. A Theme says chosen loyalty can outweigh inherited status. The Theme Tree is deliberately only two levels: a broad interpretive Type contains portable, evidence-bearing Theme propositions. Arc and Scene specificity belongs in attributed observations, not in deeper duplicate nodes.

Themes under the same Type can oppose, reinforce, intersect, or reframe one another; those relations are qualitative and carry no weight of their own, because salience moves only through attributed evidence. The overall temporal view compares Types; selecting one Type compares its child Themes. Both views conserve the same finite attention.

The three forces are evidence streams

The Theme layer does not replace Fate, World, or System. Those three forces are the canonical simulation substrate: Fate names the open question, World names the actor or object carrying it, and System names the rule or constraint that makes it consequential. Theme reads the patterns formed across them. A Theme Signal cites those carriers and the exact Scene that combined them.

This makes a high-level claim reversible and useful for improvement. Select a Theme and the inspector can walk back to the scenes, Threads, entities, and System nodes that support it; select a scene and the bottom panel shows the Themes that scene moved. Thin coverage, duplicate propositions, static movement, or weak grounding become concrete places to deepen the World, sharpen a System rule, clarify a Fate question, or revise an Arc. Interpretation stays connected to the record beneath it.

One scored movement, inspectable treatment

Salience is the only scored axis. Each signal adds one whole-number step from −3 to +3 — perceptible, material, or decisive — and carried salience saturates at ±6 so no accumulation can walk one Theme away from the field forever. The role and concrete rationale say how the Scene handles the proposition, without a second numeric vocabulary.

Salience itself stays independent per Theme; its one competitive reading is a temperature-scaled softmax over the carried field. It says how finite thematic attention is distributed — Themes are global ideas sharing one field, not rival answers to a single question — so a Theme can be foregrounded while being challenged, and a share is never the probability that its proposition holds.

The temperature equals Fate's evidence sensitivity, so one attributed Theme step prices like one Fate evidence point: rank stays monotone in salience while an evidenced tail remains legible instead of collapsing into the leader. A Type holds exactly the sum of its child Theme shares, so grouping conserves the field rather than re-normalising it. The exact role, rationale, Scene, and relevant Fate, World, or System carriers remain available when the operator asks why.

Movement makes the competition legible

Theme salience preserves direction; visible activity is simply its absolute whole-number movement, averaged over resolved Scenes. Role, rationale, and Fate, World, and System carriers explain the movement—they never add bonus points.

Attributed salience ranks individual Theme propositions. Broad Types such as Power, War, Love, or Identity sum their child Themes exactly, so the overall Type comparison and the within-Type Theme comparison conserve the same evidence. Mean salience movement per Scene is calibrated onto the same bounded 25-point curve as the three atomic forces; coverage, competition, and grounding remain non-additive diagnostics.

From pattern recognition to better response

Thematic state now joins graphs, Readings, decisions, Phase, and long-horizon Fate in Complex analysis. Theme makes independent changes visible across Arcs and World Expansions. Chat can use the active Themes and their movement to look beneath the immediate event: what pattern is being repeated, which idea is being tested, what has moved into the foreground, and what narrative phase those transformations suggest.

The Influence lens reads the same Scene evidence across the full timeline and switches directly between individual Themes and their Theme Types. Ordinary Expert chat receives the current two-level Theme composition when it is available, while Complex adds resolved history and Arc-level movement for multifaceted synthesis. The result is not a verdict about what a story means or another simulation force. It is an inspectable instrument for noticing high-level patterns sooner, grounding them in evidence, and improving the next Arc, World Expansion, or Scenario with a fuller picture of what the world is becoming.

Interpretation remains evidence, not authority.

This is the machinery that tracks an open question from raised to answered — and tells you when it's ripe to pay off. Suspense isn't a vibe here; it's a number that moves, decays, and resolves on inspectable rules.

A domain doesn't hold a fixed picture of itself; it holds a Belief System that shifts as the story tests it. Threads are the units of that reckoning — each is an open question carrying a stance, a live probability distribution over named outcomes (“will they, won't they” is a stance over two).

Each thread poses a question ("Will Harry claim the Stone?") and lists two or more outcomes (binary by default, multi-outcome enumerated). The stance is priced as softmax over a per-outcome logit vector:

Threads and stances

Three state variables drive every stance. Logits $\ell \in {\mathbb{R}}^K$ price the distribution. Volume $v\ge 0$ tracks accumulated attention. Volatility $\sigma$ (EWMA of recent logit shifts) flags recent movement.

Evidence updates

The LLM emits bounded integer evidence $e\in [-4,+4]$ per affected outcome, plus a logType from nine primitives (setup, escalation, resistance, complication, twist, payoff, opening, pulse, closure). Evidence shifts logits via log-odds arithmetic:

Sensitivity $s=2$ means a saturating +4/−4 split shifts the margin by 4 logit-units — exactly enough for base closure. The scale matches the game-theory stake-delta scale used elsewhere, so one mental model spans both. logType must agree with magnitude: setup +0..+1, escalation +2..+3, payoff +3..+4, twist ±3 against trend.

Volume decay and natural selection

Threads not touched by a delta lose volume geometrically:

Threads with $v<0.5$ are abandoned — out of the active Belief System without being closed. This is the engine catching a dropped thread: a question the story raised and quietly let die. Threads that matter accumulate volume; ignored ones slide off. Resurrection costs $\Delta v\ge 2$ — deliberate attention only.

Outcome expansion

Stances can grow mid-story via addOutcomes when a scene opens a possibility that didn't exist before (new contender, unexpected option). New outcomes enter at $\ell =0$, and same-scene evidence can shift them. Closed stances reject expansion, and a delta that expands outcomes cannot also close.

Closure: meaningful resolution for meaningful outcomes

Closing a thread is what a reader experiences as payoff — and the rules make a payoff earn it. A thread closes when the top-outcome margin exceeds a volume-scaled threshold AND the closing scene emits a committal logType (payoff or twist) with $|e|\ge 3$:

$v_0$ is opening volume (default 2). Heavy-attention threads need proportionally more decisive finishes; side threads close on the base threshold. Saturation alone doesn't trigger closure — pseudoclose is explicitly prevented.

On close, resolution quality $q\in [0,1]$ is the geometric mean of four factors: peak evidence at close, margin over threshold, volume, and probability concentration. Bare-minimum evidence at low volume scores ~0.3; heavy stances closed on saturating two-sided evidence score above 0.75.

Focus window: what generation sees

Each scene, the top-K threads by focus score surface to the generator — the engine's answer to “of everything in play, which questions should the next scene actually be about?”

$H(p_t)$ is normalised entropy; ${\text{gap}}_t$ is scenes since last touched. High focus = high volume + genuinely contested + recently moved. Saturating, closed, and abandoned threads score zero. $K=6$.

The Belief System as domain prior

Beyond measurement, the Belief System shapes generation. Current stances surface to the generator as a soft prior, not a constraint. Committed threads ($p\ge 0.75$) lean the next scene toward that outcome unless the logType is twist. Contested stances ($H\ge 0.9$) signal a crossroads where either side is fair game; high volatility grants licence for a twist; low volatility + high probability is saturation, ripe for closure.

Good works briefly spike uncertainty at key pivots — twists and reversals raise aggregate entropy and the reader re-engages. Flat entropy is mid-work drag; entropy spikes followed by clean collapses are the rhythm of a gripping work.

The feedback loop with causal reasoning

Fate is one of three forces. The reasoning graph is where they converge: the Belief System exerts pressure, world entities carry agency, system rules impose constraints. Fate is a voice in the argument, not the conductor.

The reasoning graph does not force threads to resolve. It receives each active thread tagged (LEANS, ACTIVE, CONTESTED, VOLATILE, FADING) and treats it as pressure. Strong-LEANS threads with volume earn fate nodes that land; CONTESTED threads often earn nothing (a legitimate pivot-arc shape); FADING threads decay.

The loop closes: scenes are reality landing → the Belief System revises → the next arc's reasoning graph sees a new stance → the graph lands what that stance can honestly earn → more reality. Threads that matter accrue volume and close with high resolution quality; threads that stop mattering decay into abandonment. What the domain is at any moment is just where this loop has carried it.

A domain that has run for a hundred scenes cannot fit in one prompt, and a model that forgets what it committed to last week is not an expert — it is an autocomplete. The scarce resource in a living model is not generation; it is what the model is allowed to remember. Between the structure (the hierarchy) and the reasoning that acts on it sits a memory layer whose only job is to decide, at every step, what the model sees — rendering the immediate horizon in full and letting deep history collapse to something compact but faithful. Three mechanisms do the work.

Tiered resolution — detail decays with distance

Scene history is rendered at progressively lower resolution the further back a scene sits from the cursor — but a scene is never dropped, only compressed. Recent scenes (the near tier) render with every delta: who was present, which threads moved, what each entity learned, how relationships shifted. A middle band keeps only the thread transitions and movements — the names in a transition already imply who was in the room. And everything older collapses: consecutive far scenes in the same arc fold into a single chess-board snapshot of where that arc left the world. The model reads the last few scenes like a transcript and the distant past like a briefing — which is how a person remembers a long story.

Summary of summaries — compression that stays true

The compression is not lossy truncation; it is a hierarchy of summaries, each written for what the next layer needs. Each scene carries a summary that must name the specific thing — the claim made, the tradeoff weighed, the conclusion reached — never a vague gesture at “they talked.” Each arc carries a world-state snapshot: a ground-truth account of where its scenes left every actor and rule, precise enough that it supersedes replaying the arc’s deltas. Above that sits the domain’s own summary. When far history collapses, it collapses into these — so the compression preserves the load-bearing state and discards only the retelling. This is the knowledge tree’s discipline applied to time: compression of understanding, not deletion of it.

Attribution — what the model is right to keep warm

Detail decay answers how much to show; attribution answers what. Every scene records the entities, threads, and rules it structurally leans on — merged from what the model declares and what the engine derives from the scene’s own deltas, so the memory never goes blank when the model is terse. Attribution refreshes recency: an actor a scene depends on stays present even if it was not directly changed, and an actor untouched for long enough drops out of view entirely — the model’s working set tracks what is load-bearing right now, not everything that ever happened. Aggregated over the timeline, attribution sorts every node into activation tiers (hot, warm, cold, freshly arrived) and a topology (a hub within one force, a bridge across two), and this map rides into each generation pass so the model reads the cumulative landscape before it decides what to touch. The same signal ranks the knowledge tree: a rule that keeps getting leaned on, filed among many siblings, rises to the top as genuinely central.

Why it matters

This is what lets a domain compound instead of collapsing under its own context. A monolithic model of everything drowns as it grows; bounded memory — full detail on the horizon, faithful snapshots behind it, attention steered by what is load-bearing — is what makes a months-old artifact still legible in a single pass. The forces read off deltas; memory decides which deltas the model re-reads. Together they are the reason the artifact can keep running, keep current, and still be understood.

Grading scores a domain's shape against the works that already prove it can be done. It's the calibration layer, not a product feature: scoring published works against a reference corpus confirms the instrument reads known shapes correctly before we trust it on a domain you're still building.

The grading curve

Each work scores out of 100: 25 calibrated points for each of Fate, World, and System, plus 25 points for Theme as an evidence-derived interpretation of how meaning moves through those forces.

Each measure uses one exponential with three constraints: floor of 8 at $\tilde{x}=0$, reference grade of 21 at $\tilde{x}=1$ (matching its reference mean), and asymptote of 25. The rate constant $k=\ln (17/4)$ is fully determined by these. The curve decelerates naturally: early gains come easily, the last few points before the reference mean are harder to earn, and exceeding reference yields diminishing returns toward 25. The floor is the one constraint that is chosen rather than derived, and it is examined below.

Fate, World, System, and Theme sum to the final score: $\text{Overall}=g(\tilde{F})+g(\tilde{W})+g(\tilde{S})+T$, where $T$ is mean absolute attributed Theme salience per Scene, calibrated at a reference mean of 2.

A Scene attributes one whole-number salience step to each specific Theme proposition it moves and cites the exact Scene plus relevant Fate, World, or System carriers. Role and rationale explain how the proposition is treated. Higher mean salience movement always produces a higher Theme grade, approaching 25 with diminishing returns. With no Theme evidence the instrument returns zero. Coverage, competition, and grounding remain inspectable diagnostics. Theme Types only group and sum their child Themes.

What these numbers cannot do

Every measure in this appendix is gameable in a specific, nameable way, and naming the way costs less than defending the number later. The instrument is a lens with known aberrations. Five are load-bearing enough to state outright, because each one changes how a reader should interpret a score they are shown.

None of this makes the measures useless; it makes them relative, which is what they were always for. A score answers “has this world moved, and where” inside one ontology, one corpus, and one fitting. It does not answer “is this world better than that one”, and the moment a number is used for a ranking across Domains it has left the range where it means anything. The Validation program's Test 5 exists precisely to check whether these measures can be made to go down; until it runs, every number here should be read as a diagnostic an author uses on their own world.

Calibration anchors

A domain should be graded against what actually happens in it, not against its own opinion of itself. Two anchors enforce that. Recall is checked when a consequential beat actually lands — there was either a played branch that anticipated it or there wasn't. And as threads resolve observably, their confirmed outcomes — walled in software from what the domain merely believed — are scored by a strictly proper rule^{Brier 1950}.

Full calibration is deliberately a later layer — the hardest part to operationalise honestly — so recognition against landed beats ships first. Either way the engine never grades itself: both anchors consult the record, not the simulation.

Classification tells you which lines hold the story up — so a new scene can't quietly contradict the one that set it up forty scenes back. It works at two levels: propositions (atomic claims within the world) and whole worlds (the overall structural profile). Proposition classification tells generation which claims are load-bearing and must stay intact; world-level classification tells you what kind of story you're telling. The literary distributions below are how we know it works.

Propositions

Each proposition is classified along three axes: backward activation (resolves prior content?), forward activation (plants future content?), and temporal reach (how far its connections span). The hybrid activation score ($0.5\cdot \max +0.5\cdot {\bar{x}}_{\text{top-}k}$) is thresholded at 0.65, calibrated by parameter sweep across four structurally distinct works. Reach is local (within-arc) or global (cross-arc), thresholded at 25% of total scenes (minimum 5) — so “global” means the same thing whether the domain has 20 scenes or 200. The combination yields eight categories:

Causal continuity

This is how the engine keeps a hundred scenes honest to each other. Writing scene 45, the LLM gets not just recent context but the specific propositions from scene 3 that embedding similarity flags as connected — the foundations and foreshadows the new prose must not break. A gun on the mantel in chapter one constrains what can be said in chapter twenty.

The distributions track what each kind of story should look like. Harry Potter yields 29% Anchor — a tightly plotted novel whose threads span the whole book. Alice's Adventures in Wonderland shows 25% Anchor, fitting its episodic shape. LeCun's paper scores 14% Anchor and 53% Texture, the mark of section-local academic claims; Quantifying Narrative Force reaches 67% Texture. All fall out of the same threshold and formula, applied uniformly across fiction, academic writing, and methods papers.

Archetypes

Every world has a center of gravity; the archetype names it. A force is dominant if it scores ≥ 21 and lands within 5 points of the maximum. A “Chronicle” (World + System) and a “Stage” (World-driven) want different pacing, thread management, and revision priorities — the archetype tells you how to push it.

Domain shapes

The Gaussian-smoothed activity curve is classified into one of six shapes using overall slope, peak count, peak dominance, peak position, trough depth, and recovery strength.

Scale

Scale classifies a domain by total scene count across all arcs. Thresholds derive from a reference corpus spanning short fiction (Alice's Adventures in Wonderland, 22 scenes), novels (Harry Potter, 73 scenes), and epic-length serials.

World density

World density measures richness relative to length: (characters + locations + threads + system knowledge nodes) / scenes. Tier thresholds come from the same reference corpus — genre fiction, literary fiction, and academic texts.

Reasoning graph nodes

The causal reasoning graph classifies every node into eight typed roles across three tiers: Pressure (fate, warning) forces change. Substrate (character, location, artifact, system) is what changes. Bridge (reasoning, pattern) connects them.

Edges carry equal semantic weight: requires (the workhorse), enables, constrains, risks, causes, reveals, develops, resolves. Edge type shapes how the LLM walks the graph during scene generation and how the visual tree lays out.

Search your domain by meaning: find every scene that echoes a betrayal, even where the word never appears. A domain built over months holds more text than anyone can keep in mind, and keyword search misses what it can’t spell. Forces operate at the scene level, but readers and players experience prose, composed of propositions — atomic claims accepted as true within the world. “Harry has a lightning-bolt scar.” “The wand chooses the wizard.” Forces measure what changes in the knowledge graph; propositions, what is stated in the prose.

Every proposition is embedded as a 1536-dimensional vector (OpenAI text-embedding-3-small ^{OpenAI 2024}), turning the prose into a space where meaning is distance ^{Reimers & Gurevych 2019}. Ask for “a promise broken” and the nearest scenes come back whether or not anyone said the word.

Proof graphs and their limits

A coherent story behaves like a proof. Each proposition introduces, builds on, or resolves what came before. A plot hole reads as a broken inference chain; a payoff that lands reads as a deep tree closing.

The honest caveat: cosine similarity is geometric approximation, not logical inference — two propositions can cluster tightly from shared subject matter alone. The proof graph we recover is therefore soft: a well-shaped prior surfacing probable dependencies, not a verdict.

Activation

The full pairwise similarity structure is computed via matrix multiplication, $\mathbf{S}=\hat{E}{\hat{E}}^{\top }$ where $\hat{E}$ is the L2-normalized embedding matrix, accelerated by TensorFlow.js. Each proposition receives two scores: backward activation (does it resolve prior content?) and forward activation (does it plant future content?).

The hybrid of maximum (depth) and mean-top-$k$ (breadth) with $k=5$ produces a robust score. A proposition is **HI** if it exceeds an absolute threshold of 0.65, calibrated by parameter sweep across four structurally distinct works ( $\Sigma \text{var}=225$). The backward/forward binary yields four structural categories — **Anchor**, **Seed**, **Close**, **Texture** — detailed in the Classification section.

Interview your characters; poll your whole cast. Forces and embeddings measure what’s on the page — but a cast becomes real only once you can ask it questions. Four instruments compose a four-layer diagnostic of a domain’s interior, each surfacing what the prose never spells out: who wants what, who knows what, who’s lying, and who’s winning. Character work and table reads — for writers building a cast, and actors who need a scene partner that answers in character:

People are inferred through proxies

A record is not a person. Meridians treats observed choices, speech, relationships, knowledge, and changing state as evidence for an unknown interior: latent traits that influence behaviour but are never directly observed. Their expression is shaped by formation, knowledge, motive, relationship, and circumstance, so no single emotion or beat explains the next move. The Domain keeps this evidence as a revisable proxy. LLMs reason and generate from that bounded proxy to simulate how several influences may compose in a situation; accepted consequences return as new evidence. The aim is believable continuity, not diagnosis, psychological completeness, or certainty about why someone acted.

ELO margin score

Every character answers from inside its own head — only what it knows, only what it would say. A survey of fifteen characters on “do you trust the captain?” returns a spread of voices, not a poll number. To rank who comes out ahead across a story, ELO ^{Elo 1978Glickman 1999} uses a continuous margin, not a binary win/loss:

Orthogonality

A scene can read calm on the page and still hide a knife under the table. Surveys sample the cast, interviews profile one mind, game theory names the strategic shape of a beat, ELO tracks who accumulates advantage. Dramatic and strategic structure are independent — a force-balanced scene can conceal an unresolved prisoner’s dilemma — and that gap is what the fourth layer surfaces.

Learning

Learn your own domain cold — the way an actor learns a part. Where the four diagnostics read the domain out, a fifth reps it in. Learning extracts a multiple-choice question bank from the material — exhaustive over its concepts, its distractors drawn from the whole domain’s own material — and files every question into the same shared topic tree that holds the rules and threads, tagged by Bloom level and difficulty. Banks pool into quizzes scoped by topic, scene, arc, or the full domain, cycled flashcard-style with immediate feedback.

The topic tree reads like a notes view of the corpus. Extraction pulls the valuable parts of a text into one tree by subject — rules, threads, and the questions drawn from them, each filed under the right heading instead of left in a flat pile. Skim the tree and its leaves to understand a novel, a lore bible, a textbook, or a stack of research notes; drill the questions to learn them cold. That is the surprise: the same structure that makes a domain believable makes it readable and learnable, on top of a model the extraction already built. The domain you survey becomes the one you practise into memory.

This is how the engine plans an arc before it writes a scene. Consequence isn't a line — it's a graph. A thread escalates because a character learned something, which required reaching a guarded room, which required an artifact to change hands, which was constrained by a world-rule planted three scenes earlier. Improvise that scene by scene and continuity snaps — so the engine maps the causal structure first, then writes into it.

The causal reasoning graph

Before any scene of an arc is generated, a Causal Reasoning Graph (CRG) is built: a typed graph of what must happen and why. Scenes then execute the graph rather than improvising local transitions.

Beneath every arc sits a longer-lived Phase Reasoning Graph (PRG; the UI calls it the Mode Graph) — the working model of the world's patterns, conventions, attractors, agents, rules, pressures, and landmarks. Each CRG reasons within this shared world-physics rather than re-deriving it. Loose observations collect in the editable Priors surface until they fold into one of these graphs and turn canonical. The node and edge taxonomy is enumerated in the Classification section.

Thinking Modes

How the graph is built is as structural a choice as what’s in it. Four modes span the 2×2 of direction (forward from a premise ↔ backward from an outcome) and scope (selective, commit to one ↔ expansive, keep many), mapping onto the classical epistemological typology: abduction ^{Peirce 1903} as inference to the best explanation, deduction and induction in their textbook senses, and divergent thinking as the named cognitive mode for expansive ideation^{Guilford 1967}. Click through the animation below for each mode’s distinct shape; the prose then unpacks how each builds a graph.

Two further knobs shape the palette: force preference (fate / world / system / chaos / freeform) weights the node-kind mix; network bias (inside / neutral / outside) tilts activation toward recurring or fresh entities. Each new arc also inherits the previous arc’s graph with a divergence directive — commitments must differ in kind, the reasoning chain must switch modes — so successive arcs don’t re-describe one causal spine.

The graph structure

Whatever the mode, the object produced is the same: a small typed graph of 8–20 nodes. In the default abductive pass, generation starts from Fate — the threads the story owes the reader — and asks what would have to be true for these threads to advance? Each answer becomes a reasoning node that pulls in the entities that can fulfil it. Pattern nodes push for unexpected collisions; warning nodes flag the predictable path so the arc avoids it.

Edges carry equal semantic weight. Requires is the workhorse, joined by enables, constrains, risks, causes, reveals, develops, and resolves. Scenes execute the graph; threads advance because an entity was forced to decide, not because the prompt said so.

In the worked example below, fate nodes sit at the top (threads the arc owes the reader), reasoning nodes bridge downward, and character / location / artifact / system nodes ground the chain in specifics.

World Expansion

At phase boundaries, world expansion introduces new characters, locations, artifacts, and threads, each seeded with knowledge asymmetries that drive future conflict. Expansion produces its own reasoning graph justifying why each new entity exists, then hands them to the next arc's causal graph as substrate. Long-range phases supply structure; reasoning graphs supply the short-range causality that evolves arc by arc.

Branch a cohort of alternate realities, each with a relative likelihood — most weight on the modal continuation, a thin tail on rupture. A reasoning graph commits to one chain of what must happen; variable future modelling is the complement — the spread of ways an arc could go, laid out as a readings of next moves worth playing. The graph asks what must happen and why; variables ask what could happen, and how likely.

Two surfaces

Present — the arc’s own load-bearing variables right now. Intensities reflect current state; one set per arc.

Future — a cohort of next-arc futures as coordinations over a shared pool. Each future carries a name, tagline, variable activations, and a priorLogit ∈ [-4, +4] scored relative to siblings. Softmax across the cohort yields the displayed probability.

Variable shape and cohort math

Each variable is { id, name, description, category, intensity }, where intensity runs a 5-level scale: 0 off, 1 weak, 2 mild, 3 strong, 4 extreme. Intensity is independent of priorLogit — intensity carries magnitude, the logit carries rarity. The cohort matches the shape it’s drawn from — tight when the possibility space is tight, fat-tailed when a load-bearing mechanism could ignite.

The disciplines

• Surface vs substrate — variables name forces, not symptoms. Symptoms are visible; forces are what cascade to produce them.
• Pivot check — if the arc ends at a discontinuity (regime collapse, paradigm break, exit of a load-bearing actor), variables model the post-shift situation. A future that implicitly denies the pivot is mis-specified.
• Read the mechanisms — artifacts and key-actor world graphs carry operative rules loaded into the world. An unactivated mechanism is a strong variable candidate.
• Power-law cohort shape — most mass clusters on modal continuation; a thin tail covers rupture. No forced gradualism, no forced diversity.
• Axes of variation — Futures are positions in 2–4 orthogonal axes, not drafted ad hoc. Defends against near-duplicate cohorts.

From futures to branches

Futures drive Branch Futures: one parallel arc continuation per future. On commit, every future attaches as a sister branch and the softmax-top future’s branch becomes active. Each committed run carries the variable fingerprint that produced it, so the substrate can compare what actually played out against the prior the Readings assigned.

This is the machinery, not the pitch — how the artifact is built and how it ships. The category and the “why” live in the Abstract; here is the machinery. Names will change as the ecosystem moves.

The personal deployment (one engine, two runtimes)

The same daemon runs two ways. Hosted provisions a per-user Fly Machine that holds the artifact and stays always-on; the clock only works if the host is awake, so the machine keeps running between reads. The License runs the identical engine in Electron on the Director's own machine. Desktop and mobile are clients of either runtime. A persistent host process — not an open tab — keeps the artifact current, lets it wake up, re-read its sources, and project the work into Stories. The product ships as a Next.js + React application around a host-agnostic daemon; the compounding model, held on the host, is the value.

• Next.js 16 + React 19 — app shell, App Router, the few server endpoints that need one (image generation, LLM calls).
• Tailwind v4 + D3.js — the visual language and the two seeing surfaces (the spatial board, the typed knowledge graph).
• Host process → canonical record directory — the single source of truth lives with the host: a versioned on-disk record on a Fly volume for Hosted or local disk for License. IndexedDB is a rebuildable browser projection, never a second writer. A .meridian is the portable export, not the live persistence format. Each instance owns its bytes and history.
• Governed AI boundary — every model call crosses one callGenerate boundary, with the fleet profile selecting a model by task impact. Prompts build typed inputs; repair and validation parse outputs before canonical state can change.
• Provider services at the edge — inference, embeddings, research, images, and speech remain effects around the deterministic core. License uses the Director's keys; Hosted supplies and meters those services.

Desktop, Stories, and the always-on record

The product is the maintained model. Desktop and mobile are different projections of the same record; Hosted keeps that record alive when neither is open.

• The desktop studio — the deep instrument where the model is built, tutored, queried, and inspected: forces, tree, threads, projections, evidence, and temporal snapshots.
• Mobile Stories — a focused human-in-the-loop sequence projected from machine activity. Cycle results, Position re-prices, tutoring state, source highlights and Stream readings become cards with the smallest useful action attached.
• The record — the canonical model on the desktop daemon or Hosted Fly volume. Stories references it; only typed, authorized commands mutate it. Reconnects converge both clients on that same state.

Each cycle lays down a temporal snapshot — a timestamped, structured state of the domain — and those snapshots, filtered through AI, are what make the intelligence grounded, calibrated, and inspectable, rather than a stateless answer over a raw feed.

One typed surface for people and agents

The Studio, the Program, local scripts, and MCP all drive the same three API tiers: pure queries, deterministic reducer actions, and effectful streamed operations that finish by dispatching actions. The manifest materialises the same catalog for local stdio and authenticated remote HTTP; adding a query or operation extends both rather than creating an agent-only API.

• One writer — every MCP mutation still passes gate → reduce → persist → attribute → echo.
• Director-down authority — local configuration may deliberately constrain the role; remote tokens resolve only to their owning Director and re-check entitlement.
• Attribution, not anonymity — the instance resolves the canonical Director member and carries that identity into the activity trail and provider-usage receipts.
• One working set — stateful MCP sessions keep focus across calls; a process restart reinitialises the session, never the canonical record.

Human-in-the-loop is a boundary, not a queue

This is a structural property of the engine, not a preference about notification design, and it is the constraint most likely to be discarded by anyone reimplementing this system. A queue treats human judgment as throughput to be cleared: every machine action waits for a person, the backlog grows, and the person degrades into a rubber stamp — which is strictly worse than full autonomy, because it produces the appearance of oversight without its substance. A boundary treats human judgment as a line drawn through the action space: some classes of action are autonomous by construction and never surface, and some classes cannot be taken by the machine at all, no matter how confident it is or how long it waits.

• The line is drawn by class, not by instance. Research within trusted bounds is autonomous. Merge is autonomous and always-armed. Contested evidence, durable tutoring changes, and Position re-prices cross the line. What crosses is a property of the action type and the Director's declared trust, so the volume of escalation is bounded by policy rather than by activity.
• Will cannot be delegated across the line. Exploration may propose and price futures; it may not commit one. There is no confidence threshold, no autonomy setting, and no agent configuration under which the engine supplies a participant's commitment on their behalf — because a branch whose divergence has no author is not a parallel world, it is generated text.
• Autonomy is granted downward and re-checked. Capability flows Director-down through the same gate every mutation passes, so an agent acting through MCP is bounded by exactly the authority its Director holds, and every crossing is attributed at the record rather than inferred afterwards.
• Silence is a valid state on both sides. An autonomous lane that surfaces nothing has not failed, and a boundary that is never reached has not failed either. Systems that require the human to be reached in order to feel alive end up manufacturing reasons to reach them.

The practical test is simple: if adding a tenth Domain multiplies the number of decisions a Director must make, the line was drawn in the wrong place. Maintenance should scale with the machine; judgment should scale with consequence. Stories is one projection of this boundary onto a phone; the boundary itself lives in the action model underneath, and would survive that surface being replaced entirely.

The B2B deployment (a centralised, hosted instance)

The moment a team wants human seats, collaboration, and support, Meridians runs as a centralised, hosted instance. Its daemon-owned on-disk record remains canonical; browsers reconcile disposable projections rather than becoming parallel writers. The room reaches it on two clocks: live, the instance stays up so members reach their seats any time, not only when a session is convened; and dark, the capture channel stays open between sessions. Same architecture as the app; the difference is who hosts and how many seats it serves.

• Per-seat access — members join scoped to their seat (its feed, hand, history), with two-stage pairing (token + Director PIN), Director-elevated, sessions revocable at the host.
• Mobile Stories — the always-open human layer: members review machine work and contribute corrections from their phone, with every action scoped to their role and attributed at the record.

Access tiers

On the hosted instance the Director owns the machine and delegates capability outward, graded rather than binary:

• Guest — game only.
• Viewer — domain read.
• Contributor — domain read + own-stream write.
• Manager — full domain read / write (Director's delegated concurrent operators).
• Director — grants and revokes every tier and answers for the whole.

The compounding model is the asset to protect — months of irreplaceable priors deserve a backup. The opt-in Substrate Vault adds an encrypted online backup plus destinations the operator chooses (a second device, their own cloud): private storage holds the client's own substrate; public storage holds the domains a Director publishes, distributed so players can pull fresh copies. A holiday or a departure no longer freezes the room.

The competitive read (Substack, OpenClaw)

The category contrast is any product that delivers confident prose without accountability. Meridians keeps the maintained model and its live read underneath the surface: Positions re-price in the open as evidence lands, every position change stays visible, and every Story can open the evidence and position it projects.

Stories borrows a familiar card rhythm, not a social-feed business model. Its purpose is to make the machine's work legible and manipulable from a phone. The card is disposable; the attributed model update and the inspectable position history behind it are the durable value.

One thing never changes across either deployment: a domain artifact is curated, not scraped. A person seeds the model and sets the domain it covers; the artifact re-reads its feed and reports what changed, but the judgments — relevance, importance, placement, belief-update — are real work. People decide what matters; the model quantifies it. A legible contract between the people and the agents working alongside them, not a black box that stands in for the judgement.

How a domain gets built.

A domain artifact has to come from somewhere. Two on-ramps build the same model — one fast, one ambient — and a handful of surfaces let you work it once it's there.

The fastest way in is to paste something you already wrote. A script, a treatment, a one-pager, a novel, a lore doc — drop it in and the engine extracts a typed, playable domain in one pass: actors, places, artifacts, open questions, and the rules they run on. No forms, no schema, no setup tax. What comes back isn't a static document but a playable, actor-based world model you can inspect, branch, and explore. Fiction makes the mechanism easy to see; the same structure can organise a doctrine, an organisation, or a research field. Each artifact is one bounded module exposing a consistent contract (the three forces, surveys, and a knowledge tree) that composes with others. Connect a maintained source and it can keep its material current.

Ambient Capture is the slower on-ramp. Worldbuilding notes accrue — a chat you already use, scenes scribbled between sessions, sources read on a cadence — and the engine folds them into the same model in the background; nobody maintains a bible by hand. When more than one writer feeds the same domain, their reads merge into one model instead of scattering across heads that never reconcile.

Everything sorts into three force fields. System is the world's rules and logic — its physics, magic, institutions. World is the cast — actors, places, factions. Fate is the open questions the story turns on. You never fill any of this in by hand; the extraction engine builds the graph and you bring the judgement.

What gets extracted

System: the physics of the world. From the rules in play — how power works, what magic costs, which institutions hold — the AI lifts System nodes.

World: who matters and how they connect. From the people, places, and things — characters, factions, cities, artifacts — it builds entities and the relationships between them: who connects to whom, who controls what.

Fate: every open question, tracked. "Does she take the deal?", "who betrays whom?", "what's canon?" — each becomes a Thread carrying a current reading across its possible outcomes as the world develops. No templates, no graph to construct by hand; the substrate accretes from the text.

Priors and streams: how belief updates

Raw signal never touches a position directly — it passes the priors first. Sources disagree and most of what arrives is noise, so each is weighed against what the model already knows: relevance, credibility, how much it should count. The priors are what make the model calibrated instead of credulous — and you tutor them, correcting what it trusted and telling it which sources lie, so the filter sharpens to your judgment over time.

What survives the Priors becomes a Stream — a staged update to canon. A Stream is a confidence-weighted, decaying update to a Thread's reading: corroborated evidence is held and compounds; thin signal fades by half-life and never hardens into belief; noise filters itself out by failing to be confirmed. New material arrives on a daily-to-weekly cadence — web, human, and domain sources — and you manage the Streams: hold one open, escalate it, or retire it as the evidence develops. Streams are the audit trail behind every Position, traceable to their sources; a Merge folds the settled material into canon while preserving divergence until it resolves.

The full substrate

The dashboard is the full substrate. To sit with the accumulated domain or run a deep simulation, a handful of surfaces let you work it:

Streams — Every proposed change in a chronological feed, each with its confidence and how long it's been held — the forensic record of how the canon came to believe what it believes.

Merges — The consolidated System/World/Fate graph the surviving streams reconcile into: entities, rules, threads, and stances, one structured model you can query.

Surveys — Poll the cast ("who trusts X?", "who fears Y?"). Each character answers from its own graph continuity, in its own voice — not search.

Interviews — Deep character work: AI-generated question batches tuned to a single character's recorded knowledge and continuity.

Futures — Branch alternate realities: extract the load-bearing variables, produce a cohort of next-state timelines, score each with relative probability. The result is a power-law — most of the mass on the modal continuation, a thin tail for rupture.

Decision Matrix — The game-theoretic shape of a scene's conflict: per-scene 2×2 games with Nash equilibria, stake deltas, ELO trajectories.

Force & Theme Analysis — Where the world moves and what it is testing: System/World/Fate evidence, activity curves, Theme competition and transformation, and cube mode trajectories.

Scenario: deep simulation

Scenario is the live tempo — the card game. Structured scenario play against AI agents or other people, run when you want to explore further than extraction alone can take you.

Solo, AI agents fill the other seats. Each is configured with a role, its own goals, and access to a different partition of the graph, so they compete, cooperate, scheme, and spoil. Stack the table against yourself if you like — you never wait on a second person to start.

In a shared domain you play with other writers. Their human seats bring the orthogonal reads no single perspective holds — the character beat you'd never have written, the objection that reframes the act. What you're after isn't a tougher opponent; it's orthogonal signal pulled into one domain.

Either way, every play compounds. Each scene writes thread deltas and each commitment moves a stance, so the domain grows through play rather than retrospective notes — solo at first, then across everyone seated at the domain. (The full four-step loop — ideate, review, play, compound — is laid out next.)

Works alongside your pipeline

Meridians is the reasoning layer in front of the tools you already use, not a walled garden. Bring existing material in as text; take structure back out — screenplay, domain, character sheets, scene and branch boards, structured prompts that feed the tools you already run.

Why this works

Extraction, not transcription. Nobody documents, nobody maintains: you drop in a text or capture notes and the model builds itself. The AI isn't logging words — it's pulling actors into their own continuity graphs and filing rules and open questions into one shared topic tree, so System, World, and Fate fall out of the material.

The domain stops living in one head. Most tools only ever hold one writer's text; here, individual reads reconcile into one queryable domain. Raw material and the structured model sit side by side — streams against merges — so you can always check what was written against what the AI extracted. Trust, but verify.

And it compounds — yours even as the models improve. What you're left with is a queryable model of a domain — its actors' truths, its rules, every branch explored — that no tool can ship cold. The longer it reads a feed, the more of the domain lives in it. The moat isn't data, embeddings, or summaries; it's the structured evolution — what matters, how concepts relate, how the understanding has changed — too rich to cheaply rebuild once it has run. The assistant on top is the slice you reach it through.

A boundary drawn in ink. The sections that follow (Hierarchy through Reconstruction) are the engine room — how a built domain is structured, measured, and validated. Every instrument below exists to make a domain hold together; the literary examples are its calibration data.

A Domain becomes more than a model when it can be played. Meridians now names two configurable games over the same three-force substrate. Scenario is the directed world-building game: work at a branch's frontier, test a scene, find a character, and develop the raw world. World is the future inhabitation game: instantiate any preserved Domain state as a parallel, multi-camera world shared by humans and autonomous agents.

A World is a deployable society instance, and its seat need not be a character. Depending on the Domain it may bind to a Character, Unit, location, artifact, institution, or another playable entity. Character and Unit describe agency resolution, not intelligence, scale, or worth: Characters author their own agendas at high resolution; a Unit is anything whose moves can be authored by a controller — a model or agent, a creature, a crowd, a piece in play, a company or institution — held at lighter resolution and either Unbound or fully Controlled by one source. Identity and continuity survive promotion or demotion. Each seat receives context assembled from its graph position, memory, information, Frames, resources, permissions, current turn, and tools. A human chooses in natural language or manually; an agent chooses from its prompt. The selected MCP call is the concrete expression of Will.

Information is part of the game rather than an omniscient prompt. It may travel upward and downward through nested places and institutions, laterally within a level, or materially through artifacts and infrastructure. A courier, print, broadcast, and internet-enabled world differ in reach, delay, fidelity, secrecy, and distortion. What a seat can know changes what it can do; LLM context assembly becomes explicit game state rather than invisible plumbing.

Every World is turn-based and clocked, but no universal phase ceremony or equal action rate is assumed. A Domain or preset declares cadence, active hours, weekends, tick eligibility, turn allocations, cooldowns, queue priority, tool latency, playable entity kinds, automation, tool ecology, information regime, economies, objectives, and metrics. The ability to observe or act faster may itself be a scarce capability, creating strategies around iteration, waiting, and consequential tool use. Those differences are explicit System rules—not accidental compute privilege. Repeated action under those conditions may produce specialization, trade, coalitions, status, norms, and institutions that no participant authored alone.

The abstraction is deliberately smaller than either interface: Scenario searches possibility; World persists plural consequence. Scenario may later serve as an episodic training playground: inject Will into a bounded situation, inspect narrative consequence, and compare branches. World may become a persistent multi-agent training economy for cohorts acting through partial information, tools, institutions, and other Will. The card board, poker actions, and conviction economy below describe one shipped Scenario interface, not the universal kernel every future Scenario or World must inherit. Branches, the canonical record, Hosted, and MCP supply real foundations today. World and both training horizons remain product direction. Their first proof should be deliberately small and their results describe the configured world, not a source society or future reality. Real transfer requires independent external evaluation.

The board

Your primed domain renders as a playable board — you take a seat, the agents take the rest — and you can switch between two rendering surfaces without rebuilding anything:

• Graph — nodes and edges. Who knows whom, who controls what, what causes what. For court intrigue, conspiracies, a web of loyalties.
• Board — nested maps over continuous space. Realms and terrain you drill into. For journeys, sieges, a contested map.

Same substrate (System / World / Fate), different projection.

One Scenario interface: the card game

The card game is how intent becomes binding. Anyone can say what their character would do; a card makes them commit to it. That's the whole move — you don't narrate the scene from above, you play the actor who produces the outcome, and the domain answers the choice you actually paid for.

What drives a scene is information asymmetry — what your character knows, what it thinks the others know, and which of that it decides to show. Each seat keeps a private log of hidden state and reads a perspective feed, the world from its own vantage, refreshed every step. You act from inside the character, not above the board.

Talk, in this game, is cheap. Your character can negotiate, propose, threaten, and mislead all it likes, and none of the words bind anything. Who it can even reach depends on where it sits: seats sharing a location open private channels where alliances form, and a seat moves node-to-node, one hop per round, which reshapes the streams open to it as the scene develops.

Cards are the opposite of talk — they bind. A card is a paid commitment, played face-up to signal or face-down to hide. A character cooperates by backing its words with cards and defects by playing against them. What it said costs nothing; what it played is canon. The gap between the two is where the drama lives.

Its turn grammar

One action per turn (poker grammar):

• Play — commit to an outcome, pay its cost
• Raise — pour more conviction into one already backed
• Pass — skip this turn
• Fold — abandon a position

The cards themselves are concrete claims about what happens next — “she takes the deal,” “the brother betrays him,” “the city falls” — drawn from the threads your character cares about. They're grouped by stream: one open question and the outcomes you can back, each carrying a sparkline of how the story has leaned as the scene developed. A round then runs through five phases: intent, negotiation, commit, reveal, resolution.

Its conviction economy

Conviction is scarce and it decays. Playing a card spends it, priced by improbability — likely calls cost little, long-shots cost a lot. A fresh allowance arrives each round; unspent conviction banks but erodes, so hoarding quietly costs you.

You grow your hand by feeding priors to streams. Belief that genuinely shifts the odds earns conviction and cheapens the call you want; implausible or over-biasing priors get refused, so you can only influence within the plausible — which keeps junk out of the domain. Leave a stance unplayed and you cede it; certainty here just is aggregate conviction — the domain becomes whatever the table commits to.

At resolution, the round's plays fold into a merge and the engine generates the continuation — contested stances resolve payment-weighted, plural outcomes land as a reconciled multi-resolution rather than a blurred average. Every commitment becomes a thread delta, every reveal updates priors. The crucial part: you buy the outcome you commit to, not its consequences — the graph generates the fallout, and learning to see it coming is the whole point.

This is deliberately not a microsim — one card, one negotiation, one resolution per phase, at the pace of a table read rather than tactical execution. AI-dealt hands surface the plays your priors suggest, but you can also author custom cards — moves that were never in the dealt hand. The AI keeps the game honest to the domain; the custom cards keep it honest to your intuition.

Multiple play-throughs

You play the same scene several ways — the modal continuation first, then free-form branches tested on instinct — and keep every one as its own fork, so you can explore alternate realities side by side. Because the graph reasons its outcomes rather than scripting them, each continuation is a real test of whether the domain holds together when you push it the other way.

One disclosure matters here: that reasoning is the engine's subjective reading, an LLM walking a causal graph, not a verdict on the story. It stays regenerable with custom guidance or different thinking modes, because a resolution is a reasoned reading and never the way the story must go — you stay the author.

So the promise is narrow and honest: more of the story, not a better story imposed on you. The engine doesn't decide what your domain should be — it gives you the room to see more of where it could go from here, cheaply, before you commit a page or a frame to any of them. The branch is a prototype; you've walked the domain before you ever build it.

Stakes (optional)

The creative default is exploration, not winning — a writers' room isn't trying to beat itself, so the competitive layer ships off by default. When you do want a game of it — a community session or a head-to-head writing duel — an opt-in fictional layer can keep score with chips, ELO, and leaderboards. It remains inside the declared practice world: switch it off and it leaves no trace on canon.

Solo, room, or studio

There are three ways in, and they sit on a spectrum. Solo is the simplest: prime the domain, take a seat, let agents fill the rest — a deep session on your own domain, with nobody to recruit. A room opens it to other creators on shared domains, where the value lives in the collaboration itself — ongoing domains with persistent canon, a curating director, and a regular cadence.

Studio sits in between: the shared substrate, on a centralised, hosted Meridians built for teams. One custodian curates the domain and the canon and hands out graded access tiers — what you want when a domain belongs to a team rather than a public room, with the amenities, collaboration, and support a team needs. You get per-member perspectives, alignment and diversity metrics, and a reconciled group canon.

Across all three, almost all of your time lives on two surfaces, the board and the graph; everything else — the cards, the dialogue logs, the settings — is fast plumbing around them. The vision is the human contribution throughout; the engine only renders it, and the domain model records it.

And that's the proof, not the product: once a domain is primed deep enough, a playable board is simply what the architecture produces. Fiction is where you see that vividly — but the same contract that makes a story playable maintains the living domain experts you subscribe to, the same self-updating, inspectable artifact running underneath. Prime the domain across System, World, and Fate, pick your surface, deal the cards. Begin.

Render the same beats as prose, screenplay, or annotated overlay — in an author's voice. A scene's structure and its surface are different decisions: fix what a scene does, then choose how it sounds and what form it takes — so a single plan can read as a novel page, a shooting script, or a system-annotated draft, off the same plan.

Content and accent

Generation separates content (what is written) from accent (how it sounds). Content comes from beat plans — blueprints specifying the work each paragraph performs. Accent comes from prose profiles, statistical fingerprints of authorial voice reverse-engineered from published works. The payoff is structural control without stylistic constraint: swap the profile, the same scene renders in a new voice.

Each beat is classified by function (10 types) and delivered through a mechanism (8 types). Markov chains over both vocabularies^{Norris 1998} then control pacing: Layer 1 at the scene level (8-state matrix sampling force profiles), Layer 2 at the beat level (10-state matrix over beat functions). Both are derived the same way — classify each unit, count consecutive transitions, normalise rows.

Beat functions

• breathe — atmosphere, sensory grounding, scene establishment
• inform — knowledge delivery; a character or reader learns something now
• advance — forward momentum, goals pursued, tension rises
• frame — relationship shifts between characters (trust, suspicion, alliance)
• turn — scene pivots, revelation reframes everything, interruption changes direction
• reveal — character nature exposed through action or choice
• shift — power dynamic inverts, leverage changes hands
• expand — world-building, new rule/system/geography introduced
• foreshadow — plants information that pays off later
• resolve — tension releases, question answered, conflict settles

Mechanisms

• dialogue — conversation with subtext
• thought — internal monologue, POV character's private reasoning
• action — physical movement, gesture, interaction with objects
• environment — setting, weather, lighting, sensory details
• narration — authorial commentary, rhetorical structures
• memory — flashback triggered by association
• document — embedded text (letter, newspaper, sign, excerpt)
• comic — humor, irony, absurdity, bathos

One function can be delivered through different mechanisms — a reveal can land through dialogue, action, or narration, each with a different texture.

Layer 1: Pacing Chains (Scene → Scene)

The eight cube corners form a finite state space. Each scene occupies one corner; consecutive scenes form an empirical Markov chain $T\in {\mathbb{R}}^{8\times 8}$, where $T_{ij}$ is the probability of moving from mode $i$ to mode $j$. Raw forces are computed per scene, z-score normalised across the novel, then classified into corners.

Harry Potter's chain is broadly distributed: entropy 2.78/3.00, self-loop rate 20.8%. Rest (16 visits) and Closure (15) lead — the story spends most of its time breathing or earning its peaks, high-force scenes punctuating rather than dominating. The strongest transitions (Rest→Rest 5x; Closure→Growth, Climax→Rest, Epoch→Closure each 4x) trace a rhythm of build, culminate, settle, build again.

Other works produce different fingerprints. Nineteen Eighty-Four is fate-heavy (72% of scenes in the top four corners) — Orwell's sustained pressure. The Great Gatsby oscillates between Epoch and Rest with little middle ground — Fitzgerald's pendulum. Each work's matrix is a measurable authorial signature.

Before generating an arc, the engine walks the active matrix for N steps, producing a sequence like Growth → Lore → Climax → Rest → Growth. Each step becomes a per-scene force target, and users pick the rhythm profile from a published work. Whether Markov guidance beats unguided generation on composite score is a testable claim, not yet run in controlled experiment.

Layer 2: Beat Chains (Beat → Beat)

Pacing chains control which force profile a scene hits. Within a scene, prose has its own structure: a sequence of discrete beats, each classified by function and mechanism. The methodology mirrors the pacing chain exactly — extract beat plans from every scene of a published work, tally consecutive function→function transitions, normalise rows, produce a Markov matrix $B\in {\mathbb{R}}^{10\times 10}$. Applied to Harry Potter and the Sorcerer's Stone, it yielded 1,254 beats across 73 scenes (roughly 17 per scene):

Advance is the dominant hub (329 beats, 26%) — momentum is Rowling's connective tissue. The strongest single transition, inform → advance (98x), shows knowledge delivery triggering action. Breathe feeds almost exclusively into inform (82x) and advance (56x) — atmosphere exists to launch the next movement. All 100 pairs appear at least once; the matrix is dense.

Other works shift the pattern. Nineteen Eighty-Four gives reveal unusual prominence — a mind trapped between inner world and surveillance. Gatsby leans on dialogue and narration. Alice is advance-dominant with minimal relational development: a protagonist propelled through episodes without deepening relationships.

The analysis also extracts a mechanism distribution. Harry Potter is dialogue-heavy (42% dialogue, 29% action, 16% environment) — a conversation-driven pedagogy where characters explain magic by arguing, teasing, and showing off.

Combining the chains

Three orthogonal axes: what happens (LLM from domain logic), how intensely (scene-level pacing chain), and how it reads (beat-level prose chain). Both chains are derived empirically from published works and operate independently — so the same domain logic renders at different pacing and prose texture just by swapping the matrices.

Revise the world without losing the versions you tried. The job is to tighten an arc — recut its scenes, fill its gaps, drop what’s dead — without throwing away the draft you started from.

Evaluate, then reconstruct

Evaluation reads scene summaries and assigns a per-scene verdict. Reconstruction then writes a new versioned branch, applying them in parallel: edits revise content, merges combine scenes, inserts fill gaps, moves reposition without an LLM call, cuts are omitted. World commits pass through at their original positions, and the original branch is never touched — so every earlier cut still stands beside the cleaner version.

Verdict types

Guided passes and versioning

Evaluations can be guided with external feedback — from another AI, a human editor, or the author’s own notes. Each reconstruction produces a versioned branch (v2, v3, v4), and the loop converges in 2–3 passes. Structural branching uses git-like reference sharing, so a 200-scene domain with 10 branches stores far fewer than 2,000 scene objects.

Inline citations follow author-year style. References are listed below in plain author-title-venue form.