LiminalisFour layers, and only the top one knows what a novel is.
A corpus of typed, interlinked documents. A knowledge layer continuously derived from them. A grounded conversation over that layer. And a domain-specific interface on top. This page is the walkthrough; Engineering is the same story with the numbers and the failures attached.
There is no second-class data.
A character, a chapter, a bill, a chat transcript, a validation report, a campaign premise — all the same kind of object, distinguished only by type. Around twenty-five types ship out of the box, each with its own header fields. Anything the system generates lands as a document you can read, edit, reject or build on. Nothing important lives in a hidden table.
Markdown files on disk
Your documents are files with frontmatter, not rows in someone's database. The whole index is rebuildable from them. Lock-in is absent as an architectural property, not as a promise in the marketing copy.
Rename-proof references
Renaming a document keeps every existing reference working — the old name becomes an alias. Reorganising your project doesn't quietly break the connections the system has already learned.
Folder notes: structure becomes behaviour
A folder can carry an instruction the model obeys. “Ideas, not canon.” “Voice notes only — these events did not happen.” “GM-only.” The note is injected as a guidance block from the root down, inside explicit barrier markers. No extraction, no inference — you organised your work, and the organisation means something.
Reading happens in the background, and it never blocks you.
When you save, the only work that happens is hashing, chunking and embedding the passages that actually changed. Everything expensive — extraction, summarizing, motif tagging — happens afterwards, in workers, on its own schedule. The editor never waits on a model. That's an invariant, not a performance optimisation someone might undo later.
-
The document is chunked at stable boundaries
Cut points are chosen by content, not by position — the same technique backup and deduplication systems use. Editing one paragraph of a long chapter therefore costs roughly one paragraph's worth of work, instead of re-processing the whole file.
-
Changed passages are re-embedded; unchanged ones are reused
Passages are compared by hash. Ones that disappeared take their vectors and their graph edges with them.
-
Workers extract entities, relationships and facts
A fixed ontology of roughly fifty categories and two hundred typed relations. Each relationship carries two directional summary sentences, so it can be read back as prose rather than as a graph edge label. Facts are atomic and linked to the passage they came from.
-
Summaries are written at two altitudes — and are themselves searchable
Section-level and document-level. That's what lets a long chapter be recalled at the right resolution rather than all-or-nothing.
-
Motifs are tagged
Theme-language keys that let you retrieve by what something is about, across folders, regardless of whether it shares a single proper noun with your query.
-
The generated knowledge documents are refreshed
A Reverse Index, a Project Overview, a Context Summary and a Structure document — the system's own always-current understanding of your project, written as documents you can open and correct.
Each pass records the signature of what it last processed against the document's current signature. Four useful properties fall straight out of that: it's resumable (a restart re-derives the pending set from disk — there's no queue to lose), incremental (unchanged documents are skipped by hash, not by timestamp), independently staged, and failure-tolerant without wedging — a permanently malformed document doesn't spin forever, it just retries the next time you edit it.
Five things run before a single token is generated.
- 1 · Pins
-
Deterministic and always included: the project overview, anything you forced in, any
@-mention, and — crucially — every document whose name you actually said, resolved through the reverse index. Two access barriers strip pins you aren't allowed to see before anything else happens. - 2 · Recall
- A loop that runs several cycles: search, then seed the entities named in what came back, then let the graph walk pull in their documents, then search again. Older material decays each turn so a long conversation doesn't accumulate sediment.
- 3 · Fusion and reranking
- Keyword search and vector search are fused by rank, so the cross-encoder that scores the final candidates gets to see lexical-only matches too — the ones a purely semantic search would never have surfaced.
- 4 · Rendering
- Small documents render whole. Large ones render the parts that matched, expanded outward and merged — never a head-slice. A head slice is the worst possible failure shape because it's invisible: the reader believes it has seen the document.
- 5 · Budget
- If it's still too big, it degrades in order of least damage. Pins are never dropped, and every clip is marked in the text, so the model knows it's holding a partial document rather than confidently answering from a fragment.
Step two isn't a search index — it's a graph that changes as you work. Every passage, fact, entity and summary is a node carrying an activation level computed the way the ACT-R cognitive architecture computes it: recency and frequency in one number. Connections strengthen when both ends get used together, weaken when they don't, and are eventually pruned entirely — the graph forgets on purpose, because a graph that never forgets becomes a mesh where everything is faintly connected to everything.
The practical effect is recall with something like intuition: because how easily a thing is reached depends on how warm it already is, the system can surface material that shares no keyword with your question and sits nowhere near it in embedding space — purely because in this project, over time, the two became connected. Two projects with identical documents but different histories will answer the same question differently.
How resonance works →The “what's in context” panel
Every document that fed the answer, its score, and how it was found — pinned, matched by keyword, matched by vector, pulled in by the graph, or tagged with a motif. Grounding you can't audit is just a claim.
The context depth indicator
How far back the conversation's memory actually reaches, with the rolling summaries it was built from expandable underneath. Recent turns stay verbatim; older ones compress.
Nothing is added to your project silently.
Draft proposals
New documents arrive as drafts you accept or discard. Chat command results render in the conversation and are added only when you say so.
Selective editing
The assistant can change one sentence without rewriting the document around it. Proposals are reviewable, and an edit's anchor must match exactly once — so a change can never land in the wrong place.
Provenance & canon
Authored versus generated, canonical versus draft versus flagged. The model is told to prefer your text over its own on any conflict rather than averaging them.
Thinking levels
Five rungs from a direct answer to draft-critique-revise, chosen automatically or by hand, with cost scaling accordingly.
Model choice per job
Pick the chat model per session, and assign every other job — extraction, summarizing, scaffolding, critique — to whichever model suits it.
Visible background work
A live indicator of what the system is doing to your material right now: analyzing, summarizing, tagging, indexing.
The same story, with the numbers attached.
Including the benchmark ladder, the context-cache mechanism, the pipeline graph — and the experiments that failed.