The maintained expert

Meridians is an operating system that keeps a live read of your world — and routes you through it. Give it a domain or a goal — the AI frontier, a market, a conflict, a company, or your own fitness or career — and it reads the world for you, cuts the noise down to the evidence that matters, battle-tests the questions that count against what's actually happening, and turns that read into a plan that tells you your next move. It holds the questions in view, re-routes the plan as the evidence turns, and stages what to do — for you to confirm. You never start cold: it continues from a model that remembers, and a journey it is walking with you. Being informed is common; knowing what to do about it, in time, is the edge — and that is what it hands you.

The product is that model: a structured, inspectable account of the domain's actors, rules, evidence, and open questions — and the live plan it lays over them. It runs one Program — Watch, Opinion, Tutor, Route — so understanding compounds, and your decisions improve, rather than expiring after each answer. Most cycles are quiet. When something earns your attention, Meridians shows the position before and after, the evidence that moved it, why it matters, and — when a plan is live — the next move it recommends.

It does not treat every link equally. Evidence is weighed by relevance, source quality, and fit with the question it bears on. Each open question holds a probability distribution; each credible development moves it by what the evidence is worth. Over time, the trajectory becomes as important as the current answer — and the trajectory is what a plan is built on: you can see what the expert believed, what changed, why, and how that turned the road ahead of you.

You tutor the expert. Choose the questions and sources that matter. Correct what it trusted, how it framed a cause, or where it filed a concept. A correction does not merely repair one output; it changes the durable model the next cycle uses. Two people can follow the same domain and develop different experts because each has taught a different standard of relevance and judgment.

The relationship rests on a deliberate division of labour: the machine attends; the human judges; the model remembers; evidence revises. The line is drawn on purpose — delegate maintenance, not thinking. Meridians takes the mechanical upkeep of a changing world: monitoring, gathering, synthesis, routine belief maintenance. You keep authority over what matters, what to trust, what should become durable, and what claim is worth putting on the record — and you keep authorship of your own understanding. You are not a QA engineer checking its output; you are the operator, and the point is that you grow sharper, not only the expert.

A Route turns understanding into movement. Name a goal; the expert lays a hedged plan — a decision graph of stages, with the complications pre-empted and contingency branches ready — but only after layers of reasoning. A causal Graph identifies leverage, dependency, and consequence. A Reading holds multiple variable futures and their relative bearing from an explicit temporal vantage. The Route turns those artifacts into the main line, hedges, timing, and monitors you can execute. You hold a live position on that plan. At each stage the expert monitors the signals that matter there, and when the world moves it re-routes and stages your next move for you to confirm. A Route is never graded right or wrong; like a GPS it re-routes as conditions change, and it is maintained for as long as your goal is live. The point is not a leaderboard, and it is not doing the work for you: it is guidance with skin in the game — you watch the plan re-route with the evidence, inspect the reasoning behind every move, commit each step yourself, and the Route remembers the journey you actually walked.

This is the edge the machine is built to give: an expert that maintains a fresher, better-read view of the world and converts it into your next move before the advantage decays — information-recency arbitrage, run continuously on the domains and goals you care about. We guide the journey; you do the living.

Stories is the fast human loop: material changes and pending judgments arrive as finite cards you can inspect, correct, accept, or defer. The desktop studioopens the same model in depth. The intelligence lives in neither surface; both read and steer one canonical artifact.

A feed tells you what happened. A chatbot answers what you ask. Meridians maintains what you currently understand — and does what neither is built to do: it hands you a plan, and tells you your next move, including the message a yes-man never sends: the evidence is turning — here is how we re-route.

The direction of travel is external → internal. The external instrument comes first: extraction, structured domains, research cycles over the web, the maintained Program, and the studio ship today. Routes are the next product layer over that foundation. Then the same machine turns inward — a personal operating system built on your own signals, so the same loop guides real change in your own life: a Route through a fitness arc, a career move, a health protocol, pre-empting the complications and staging each next step. Unattended Hosted monitoring, mobile Stories, and personal domains are the product direction; the sections that follow separate those claims and show the machinery beneath them.

Nothing maintains your view of a moving domain.

If you follow something seriously, the work never ends. Sources multiply. Important questions remain open for months. A new development may change everything, confirm what you knew, or add noise. Keeping a coherent read means remembering the prior state, weighing the new evidence, and updating by the right amount.

People are poor at this under attention pressure. We anchor to a view, lurch with each headline, drown in noise, or stop updating without noticing. Doing better requires more than access to information: it requires a memory of what you believed, a filter that separates signal from noise, and the discipline to update by the right amount — moving a probability by what the evidence is actually worth, not by how loud it is.

Existing tools solve adjacent problems. A feed tells you what happened but holds no position. A chatbot answers what you asked but does not maintain the answer. A knowledge base stores claims but does not re-read the world. A dashboard trips a threshold but cannot judge what the change means — or what to do about it. Each leaves the synthesis, and the next move, to you.

This is an attention and judgment problem. Machines can read more than a person; they cannot decide which consequences only that person should own. The useful boundary is persistent machine attention with concentrated human judgment.

Meridians holds that boundary. It keeps the questions and positions, filters new evidence through a model you can inspect, and interrupts only when something changes the picture or needs your judgment. You stop rebuilding context and start refining it — and refining a model you can read is how you come to understand a domain, not just track it.

Why now: frontier models can reason across enough context to maintain a domain, while inference is cheap enough to revisit that context repeatedly. The opportunity is no longer a better answer. It is a maintained position that tells you, in time, what to do next.

The product is one model running one Program. Watch reads the web and weighs the evidence against every open question. Opinion filters the movement down to what deserves attention. Tutor turns reviewed evidence and corrections into durable understanding. Route turns that understanding into a live, hedged plan and stages your next move. Each pass begins from the state left by the last — noise in, sharper thinking and better decisions out.

It keeps up

On a cadence suited to the domain, Watch revisits trusted sources and the questions already in play. 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-routes a plan, resolves a question, or exposes a gap in the model. Quiet is a valid result.

It learns your judgment

Tutor is where you write on the model. A correction can change what a source is trusted for, how a question is framed, which cause explains a move, or what the expert watches next — and it persists, so the next cycle starts from your standard, not from scratch. This is the line the whole system is built around: delegate the maintenance, keep the judgment. The machine is never asking you to rubber-stamp its work; it asks for judgment only where that judgment changes what it does next.

It routes you to your goal

Route turns an opinion into a plan you can walk: a goal, a decision graph of stages, and the complications pre-empted as contingency branches. You hold a live position on it. Watch monitors the signals that matter at your current stage, and when the world moves the expert re-routes the plan and stages your next move — which you confirm. It is never graded right or wrong; like a GPS it re-routes, and it stays live as long as your goal is. The journey is a property of the expert: every re-route and every step is inspectable, attributable, grounded in the source that caused it, and remembered — so you carry the lesson, and the path you took, into the next goal.

The human loop is a learning-and-guidance loop

The machine runs Watch → Opinion → Tutor → Route. The person experiences orient → judge → commit → learn → refine — and lived from the inside that is a learning-and-guidance loop: you consume what moved, explore the model behind it, learn as its read sharpens, tutor it toward your judgment, and route — put a goal on a plan and commit each move as it advances. Most cycles require only orientation. Stories keeps that interaction finite and is where you confirm the next step; 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 first tested on finished stories, where coherence can be compared with known ground truth. That validates the instrument backward; the evidence gates later in this paper define what must still be proved forward.

We built a representation for expertise and called it domain, because that is where the problem first made sense. An expert's belief is never a bare fact — it is a position, plus the evidence behind it, plus its causal history, plus its predictive weight. That is exactly what a character's belief is in a story, and exactly what a domain engine already knows how to keep coherent: it won't let a belief jump without the reasoning and continuity that justify the move. Point that machinery at a market or a research field instead of a plot and nothing changes but the subject.

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.

From a cold start to a guided first move

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 Route. The Route does not move the person automatically; it stages a reasoned next move, and the person commits it.

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 Route remembers the journey actually walked. 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.

This paper describes the product Meridians is becoming while keeping the boundary visible: the instrument and much of its operating engine exist now; the seamless guided journey is the next delivery push. The roadmap succeeds when that journey feels inevitable to the user, not when every subsystem merely exists.

The Harry Potter test

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. If the engine can find the shape of a finished novel, it can find the shape of a domain you actually follow — and reading that shape as it forms is what lets it guide a live goal forward.

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; the math is fully deterministic, and cross-run validation confirms stable rankings.

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 market quarter all accumulate those same three things, and the same math reads them. The domain case is shown; the cross-domain 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 — or a market regime — is the next thing to prove. The ground is chosen: replays of real situations with known ground truth, run under the original fog by cohorts who don't know us, scored against what actually happened, published either way. Each call is timestamped before reality answers, so the test grades the recorded read, not the remembered one — and it repeats, not a single lucky pass.

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 the proposed 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 the move it wants you to confirm now — not just an update to read, a decision 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.

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 Route moves. Actions stage intent for the next eligible run, remaining editable until reservation. Trust stays granular: Research may be autonomous while Tutor changes and Route moves stay reviewed — the machine guides, but you commit each move.

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. The first test is therefore narrow: the first evidence brief, the first grounded Route proposal/next move, and one Tutor correction; four actions — inspect, accept, correct, defer. Ongoing Monitor upkeep joins only when it is material. Stories graduates only if 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 operator pays for the instrument

The base business works at one user: a Director pays for a maintained expert that keeps up with a domain and improves their decisions. No audience, public profile, or marketplace is required for the product to earn its price.

A Director — the person who seeds, tutors, and publishes an expert — pays a small weekly price, BYOK: they bring their own API keys, so the platform's inference COGS is essentially $0. They can run it on their own machine — the self-host License at $3.99/week — or let us keep it live on a managed always-on VM, Hosted at $5.99/week, without them running a box. Provider usage stays on their own keys in both cases. That is the whole operator bill: $3.99/wk self-host, $5.99/wk managed, unlimited experts. A coffee a week.

If users later publish experts and charge an audience, Meridians can add a second rail: subscriber billing with a rev-share of roughly 18%. That is credible network upside, but it follows operator value and retention. Operator billing ships first; public discovery, comparable maintained Routes, and Stripe Connect come later.

Unit Economics — BYOK ⇒ ~95–99% platform margin

Inference is BYOK, so the operator carries the LLM, embeddings, images, and crawler on their own keys — it never touches the platform P&L. That collapses our cost base to almost nothing: on managed operators we pay Flyfor the box, Stripe on the license and VM we charge, and a fixed control-plane floor (~$45/mo) amortised across all operators. Every platform margin can run ~95–99%. Any later subscriber revenue sits on top of that near-flat base.

Read the table across: our take on an established operator is ~$920/mo at ~99% margin — the ~18% rev-share on 500 subs @ $10, plus their $5.99/wk managed license, against a near-zero cost base — while the operator themselves nets ~$3,700/mo. Scale that to a hit — 5,000 subs @ $12 — and the platform earns ~$10.8k/mowhile the operator clears ~$45k/mo. The two sides move together: the operator gets rich, we take a compounding cut, and because inference is BYOK the cut is almost all margin. A solo operator with no audience is just the license, so the downside per account is bounded and the upside rides the creator's growth.

Sourced, small-scale estimates (2026): rev-share take 18% (range 15–20%) of subscriber gross via Stripe Connect; operator license $3.99/wk self-host or $5.99/wk managed (BYOK), weekly. Platform cost base: Fly shared-cpu-1x $2.02–$5.92/mo (managed operators only), Stripe 2.9% + $0.30 + 0.7% Billing on the license/VM we charge, and a Supabase Pro ($25) + Vercel control plane amortised across all operators (~cents each). Inference, embeddings, images, and crawl are BYOK — the operator's own keys — so ~$0 platform COGS. Figures from src/lib/economics/unit-economics.ts.

The inference bill — always the operator's (BYOK)

Inference is BYOK on both runtimes — the operator's keys, the operator's account — so the LLM bill never lands on the platform. It's a real cost, but a small one, and it's the operator's to optimise. A living-domain expert runs on the order of ~$2–5/mo of inference; the model tier is the lever:

So the regime decides the bill. The living-domain loop — reading sources and publishing what moved — is only ~$2–5/mo of inference. Heavy creative generation lands around ~$18–21/mo, dominated by output tokens on the performance tier (Gemini 3.5 Flash at $9/1M out is ~80% of it; caching trims input 60–80%). Whichever regime an operator runs, it's their key that pays — theirs to optimise, and the reason platform COGS stays at ~$0 regardless of how hard an expert is worked. The model tier is the lever, and it stays under one frontier-chat subscription.

Every service the engine touches (and who holds the key)

The complete cost surface — and, next to each line, who bears it. The operator holds every generation key (BYOK) on both runtimes, so the LLM, embeddings, image, and crawl prices below are always their cost, never the platform's. The platform carries only the always-on box (managed operators), the shared control plane, and Stripe. Sourced 2026 list prices:

Read top to bottom, the split is clean: the operator carries every generation key, the platform carries a near-flat base. Because inference, embeddings, images, and crawl are all BYOK, none of them touch our margin no matter how hard an expert is worked. Our only lines are the always-on box (managed operators only), an amortised control plane worth cents per operator, and Stripe on the license and VM we charge — with the subscriber processing fees sitting on the operator's Connect account, not ours. That is why the rev-share cut is close to pure margin and the platform clears ~95–99%.

Why the buyer pays (a living expert vs a static answer)

Querying an LLM is everyday value; a self-updating expert that hands you the next move is the lock-in. Anyone can ask an LLM a question once. A Meridians artifact keeps living — it re-reads its sources on a cadence, re-reasons, reports what changed that meaningfully updates the model, and re-routes the plan toward your goal — so understanding is cultivated over time instead of produced per query and forgotten. The compounding artifact turns a subscription into a relationship: the longer it monitors one domain, the more of its state, history, and explored branches live in it, and the more expensive it is to rebuild cold. What compounds is the structured evolution of understanding (what matters, how concepts relate, how the model has changed), not data or embeddings anyone can scrape. Yours, even as the models improve.

The personal product

The Director starts with a domain and its sources. Meridians drafts the actors, rules, open questions, and a first Route toward a goal; the Director corrects the structure and names the goals worth maintaining. The studio makes that model inspectable. Hosted monitoring and Stories later carry the same loop when the desktop is closed.

The conversion event is not a clever first answer. It is the moment the user sees that a correction persisted, a Route re-routed toward its goal, or new evidence changed a position before they rebuilt the context themselves.

A business at N = 1; network upside later

Operator licenses are the floor. If public experts later attract paying audiences, rev-share becomes an additional line rather than a rescue for weak individual value. The conditional network scenario is in Network Scenario.

A public network is worth building only after users maintain private experts, enough Routes mature under comparable rules, and publishing creates organic demand. Until then, retention and better decisions are the acquisition proof.

The commercial claim is still unproven, and we hold it to the same standard as the engine: it moves only when the evidence does. The risks that would sink it, and the gates that have to clear first, are set out in What has to be true — deliberately the last word of the paper, not a footnote to the business model.

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 a marketplace to be useful. A private expert earns its place by maintaining one person's understanding. If users later choose to publish their experts, the same artifacts can form a network without changing the core product.

Routes give that network a harder trust signal than followers or reviews. A follower count says people watched; a Route shows the journey they watched — a live plan toward a goal, its full position history, and the evidence behind every re-route, traceable move by move. “Battle-tested” then means a maintained model you can inspect, not a marketing claim.

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

This is a possible network effect, not the opening proposition: strong public experts become useful starting points for other people, while private experts remain owned, local, and complete products in themselves.

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 Routes. 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 Route — a plan re-routing in the open as evidence lands, its journey 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 it can sharpen itself: a tutored expert builds a deeper maintained Route → surfaces higher in the library → 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):

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

BYOK is the reason the curve doesn't bend down. The operator supplies their own keys, so the platform bears ≈ $0 inference COGS no matter how hard an expert is worked. The only real platform cost is a fixed control-plane floor, which amortises across every operator — so gross margin doesn't erode with scale, it climbs toward ~97%. A paying operator is near-pure contribution and the rev-share tail is long, which is why LTV/CAC runs from ~13× (conservative) to three digits, at roughly one-month payback. This is the rare shape where growth makes the margins better, not worse.

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.

The technical thesis is only half the risk. Meridians also asks people to form a new habit: maintain a model, teach it judgment, and commit the next move it stages 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 planning as separate tools and leaves before one goal becomes a grounded expert and a reasoned next move.
• 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. Watching a position turn against you can improve judgment, but it can also threaten identity. Routes re-route in the open and go dormant once the goal is reached rather than settling into a verdict — like a GPS, never scored right or wrong; private reflection by default, and postmortems that teach rather than punish.
• 7.Confidence outruns evidence. A coherent, inspectable model can still invite automation bias. Uncertainty, source limits, disagreement, and durable human overrides must remain visible.

Evidence gates

• 1.The first loop completes. A new user can move from one goal to a grounded expert, understand a material Story, inspect the causal, variable, and temporal basis of a Route, and commit one next move 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 Route, reverse few autonomous actions, and still describe the expert as theirs at month six.
• 7.A network is requested, not presumed. Retained users maintain experts, export or share them, and ask to discover others before Marketplace 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.

Strip everything back and one identity is left. Meridians is an operating system for sharper thinking — and for acting on it. It turns the world's noise into evidence, pressure-tests your thinking against it, and lays that read into a plan that guides your next move. Everything in this paper — the memory that compounds, the Program on a clock, the coherence check, the maintained record, the Route that carries all of it toward a goal — serves that one sentence. Being informed is the commodity; knowing what to do about it, in time, is the scarce thing — and that is the line it holds. It is what a feed can't do, because a feed reports what happened and has no idea what you think or where you're headed; and what a general assistant won't do — hold a position over time, revise it in the open as the evidence turns, and re-route the plan underneath it, not answering once and forgetting.

What we are really building is the analyst class, democratized — and put to work with skin in the game. The privilege of a research desk — someone who covers your domain, holds a live position on every question that matters, hands you the next move, and answers to you — becomes something anyone can keep, on any domain or goal they follow, for the price of a subscription. It doesn't just tell you what it thinks; like a GPS it lays a route to where you're going and re-routes as the road changes, and you confirm each move — it has skin in the game because you do. And it arrives with a property human analysts rarely offer: a maintained record and a standing invitation to inspect it. Every call revises in the open, every re-route on the record. Public comparison may follow once domains have enough comparable, battle-tested Routes; accountability begins in the private expert.

The parts are copyable and the models will keep improving — both true, and neither is the moat. No general assistant will commit to a live, re-routing plan with its reasoning in the open and its journey on the record; that is the one thing they structurally won't do. And even one that did could not ship the expert you taught: six months of corrected positions, trusted sources, maintained calls, and routes walked to their goal — none of it rentable, because no one else's expert was tutored by you or knows the journey you took. Sharper base models only make it a better instrument in your hands. Start with a single domain; the power arrives as the ecosystem does.

But the expert is the mechanism, not the point. What compounds alongside it is you — six months of watching a read form, turn, and hold up, and of walking a plan you re-routed with the evidence, teaches the person as much as the model. Meridians delegates the upkeep of a changing world and the plotting of the road ahead so your attention goes to understanding and to moving; you stay the author of your own judgment and the one who takes each step, and grow sharper for it. First on the domains you watch, then — as the machine turns inward — on the life you live: a route through a fitness arc, a career move, a health protocol, the complications pre-empted and each next step staged for you to take. We guide the journey; you do the living.

It keeps your world current and points the way through it, so you grow sharper as you go.

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. Same formulas, different signatures. (Genre-neutral underneath: the same three readings score a market just as cleanly.)

The three forces

Activity and swing

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, or Streams). Each band is one container — a question, an entity, a rule — and its width at every scene-bucket equals the attention it drew. Bands enter, swell, hand influence to one another, and resolve.

Type mode re-groups the same flow by log kind instead of container.

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).

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, stall, pulse, callback). 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 points to each of the three forces, plus swing: the Euclidean distance between consecutive force snapshots, a measure of how much a story breathes. The curve is calibrated so published works land in the 85–92 range, which gives a number on your own draft a meaning you can read.

A single exponential with three constraints: floor of 8 at $\tilde{x}=0$, dominance threshold of 21 at $\tilde{x}=1$ (matching the reference mean — the threshold the archetype classifier uses), 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. Quality bands: bad (8–15), mediocre (15–20), good (21–25); reference works land between 85 and 92.

Each force is normalised against a reference mean so scores are comparable across works of different signatures and lengths. The overall score sums all four sub-grades: $\text{Overall}=g(\tilde{F})+g(\tilde{W})+g(\tilde{S})+g(\tilde{\sigma })$, where $\tilde{\sigma }$ is swing. Swing values are already mean-normalised during distance computation, so $g(\tilde{\sigma })$ is applied directly to the average swing magnitude.

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:

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 rehearse 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 scenario 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 scenarios as coordinations over a shared pool. Each scenario 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 scenario 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 — Future scenarios are positions in 2–4 orthogonal axes, not drafted ad hoc. Defends against near-duplicate cohorts.

From scenarios to branches

Scenarios drive Branch Scenarios: one parallel arc continuation per scenario. On commit, every scenario attaches as a sister branch and the softmax-top scenario'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 substrate ships as a single Next.js + React 19 application whose backend only passes calls through to an LLM gateway; 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 → encrypted .meridian file — the single source of truth lives with the host, serialised to one .meridian artifact: a Fly volume on Hosted, local disk under the License. The browser is a stateless client of it. No shared multi-tenant database — each instance owns its own bytes (your VM or your machine), client-keyed and portable. That's a fact of how it runs, not the pitch; what earns the subscription is the compounding model, not where the bytes sit.
• LLM gateway (OpenRouter) — pass-through inference; routes to the cheapest model that clears each stage's bar (currently DeepSeek for generation, Gemini Flash for planning / analysis). Always-on, calling out only for inference.
• OpenAI embeddings + Replicate — 1536-dim vectors over every scene, beat, and proposition for semantic search; Seedream 4.5 for board art and covers.

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, routes, evidence, and temporal snapshots.
• Mobile Stories — a focused human-in-the-loop sequence projected from machine activity. Cycle results, Route re-routes, 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.

The B2B deployment (a centralised, hosted instance)

The moment a team wants human seats, collaboration, and support, Meridians runs instead as a centralised, hosted instance. The console is the single source of truth — no sync, no merge, nothing to conflict — and 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 guidance underneath the surface: Routes re-route 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 deployable, actor-based simulation you can survey, branch, and play forward. A fictional world is the cleanest proof the architecture works — the same engine reads a market, a doctrine, or a research field. Each artifact is one bounded, self-updating module exposing a uniform contract (the three forces, surveying, a knowledge tree) that composes with others; point it at a live feed instead of a one-off text and it keeps itself 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, priced. "Does she take the deal?", "who betrays whom?", "what's canon?" — each becomes a thread carrying a stance, a probability distribution over the outcomes that updates 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 — the pull request of the system. A stream is a confidence-weighted, decaying update to a thread's stance: 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, auditable to the source; the merge is the canon they add up to, divergence preserved until it's resolved rather than averaged away.

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.

Scenarios — 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 Analysis — Where the story moves and where it stalls: System/World/Fate metrics over time — activity curves, swing analysis, cube mode trajectories.

Rehearsal: deep simulation

Rehearsal 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 from rehearsed play rather than retrospective notes — solo at first, then across everyone seated at the domain. (The full four-step loop — ideate, review, rehearse, 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 playable fiction is where you can see the capability, vividly and fast — the proof that once a domain is primed deep enough, a coherent, queryable model is simply what the architecture produces. The same domain that speaks the three-force contract everywhere else becomes playable here: prime a domain across System, World, and Fate, take a character's seat, and play a scene forward. Solo means you against AI agents in every other seat — improv partners who hold their own characters and push back. Social means a writers' room: a few people around one domain, each driving a perspective, reconciling their takes into canon. It's vivid, fast, and impossible to fake — which is why we prove the engine on fiction first.

In the solo game you prime the domain and take one seat; agents fill the rest, playing their characters honestly — competing, cooperating, scheming, spoiling. Each drives its entity from a private log of what it knows and a perspective feed scoped to what it can actually see. No omniscience: an agent acts on its character's information, not the author's. That's what makes the scene partner believable rather than a puppet reading your mind.

Solo has an honest ceiling. An agent can only surprise you with something the model already contains — roughly the distribution your own imagination draws from. Agents recombine what's in the domain; they can't import the orthogonal instinct another writer brings. They make excellent scene partners and poor substitutes for a room. Played carelessly, solo becomes an echo chamber that sharpens what you already see but can't, on its own, surprise you the way a collaborator can.

The writers' room is how you break that ceiling. Human seats bring the orthogonal reads — the character beat you'd never have written, the objection that reframes the act — that no agent can manufacture. The room reconciles those takes through the same merge that folds the solo table; divergence is preserved, not flattened, so the domain keeps the better idea instead of averaging the two.

As for when to play — Rehearsal is the live tempo. Ambient Capture carries the everyday worldbuilding between sessions; you sit down to play when you want to test a scene, find a character, or branch the story. The full surface is available, never required.

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.

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.

Taking your turn

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.

Rehearsal as a resource

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, a head-to-head writing duel — an opt-in fictional layer keeps score with chips, ELO, and leaderboards. The reality-anchored and real tiers belong to the engine's strategic mode (projecting against the record), kept fully separable: switch the whole layer off and it leaves no trace on the world.

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
• bond — 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 bonding: 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.