Mova0.6 pre-release⌕
☰
home / pipeline

The pipeline

How Mova reads a text and answers from it: the text is cut into tokens, parsed into a Universal Dependencies tree, read into frames, gathered into a world, and the answer comes from that world with its reason. Every step is deterministic and can say why. The way back writes the world as text again, byte for byte, and measures what each layer loses (in detail: the autoencoder). A large model is only a teacher, in training; it never answers. How all of it is trained and measured: how Mova is trained.

Diagram Example The way back The autoencoder → Training loop How Mova is trained → Text → tokens Tokens → tree Tree → frames Frames → world World → answer Learning And back

Reading: text → answer

Text
text, every byte
Tokens
forms + the gap before each; lemma, tag, features
Tree
UD tree (CoNLL-U): head and relation per token
Frames
frames: event, verb class, roles, tense, links
World
entities by id + the line of events
Answer

an answer, with its reason

The way back: world → text

World
frames, + residual 1.3–2.1 bits a token
Frames
tree, + residual 6.0–8.6 bits a token
Tree
tokens, + residual 1.1–5.1 bits a token
Tokens
text, + residual 0–0.09 bits a token
Text

the same bytes as the input

Learning: the training loop

The training loop: drafts, witnesses, agreement, the teacher checks, the parse database, the trainer, and new draftsDraftsthe small model parsesWitnessesopen parsers parse tooAgreementthe trees are votedTeacher checksa large model + UD gatesParse databaseagreed trees, labelsTrainerretrains the small modeltraininground after roundanswers: no large model
Between the stages, the data that passes; on the way back, the residual each layer needs to give its input back exactly (bits a token, five corpora, measured 2026-10-18; the autoencoder explains them). The loop is how the models are trained; a large model is in it only as the teacher.

One story through every stage

Real output of Mova's own tools on one short story · run 2026-10-23 · commit 20e228852 · model en.bin of release 0.4 (sha256 31a93401fe71…). Each step names the command that printed it; the commands and the model are in the quick start.

The text

A three-sentence story and a question about it.

Mary went to the kitchen. She picked up the apple. Then Mary went to the garden.
Where is the apple?

Text → tokens

Each sentence is cut into tokens; the gap before every token is kept, so the text can come back byte for byte (roundtrip probe).

tokens  Mary | went | to | the | kitchen | .
tokens  She | picked | up | the | apple | .
tokens  Then | Mary | went | to | the | garden | .

Tokens → tree

The tokens' lemmas, parts of speech (UPOS and the Penn tag) and features come with them from the tagger; the tree adds each token's head and relation: a Universal Dependencies tree in CoNLL-U (en annotate; the second sentence). SpaceAfter=No on the full stop is the parser's view of one sentence alone; the space between sentences is kept by the tokens, as the gap before the next sentence's first word.

# text = She picked up the apple.
1	She	she	PRON	PRP	Case=Nom|Gender=Fem|Number=Sing|Person=3|PronType=Prs	2	nsubj	_	_
2	picked	pick	VERB	VBD	Mood=Ind|Number=Sing|Person=3|Tense=Past|VerbForm=Fin	0	root	_	_
3	up	up	ADP	RP	_	2	compound:prt	_	_
4	the	the	DET	DT	Definite=Def|PronType=Art	5	det	_	_
5	apple	apple	NOUN	NN	Number=Sing	2	obj	_	SpaceAfter=No
6	.	.	PUNCT	.	_	2	punct	_	SpaceAfter=No

Tree → frames

The tree is read into frames: the event, who did it, to what, where. «She» is already resolved to Mary (roundtrip probe). A frame line shows the roles only; the frame also keeps the tense, the words around its roles («to the») and the link to the clause before («Then»), and the frames line is the sentence said back from the frame alone, exactly.

  frame Event Mary go place=kitchen
frames  Mary went to the kitchen.
  frame Event Mary(She) pick up patient=apple
frames  She picked up the apple.
  frame Event Mary go place=garden
frames  Then Mary went to the garden.

Frames → world

The frames of the story become one world: its entities, and the line of its events with roles as ids (roundtrip probe). The question reader keeps the state it answers from: where each person is, who holds what, where each thing has been (world babi-probe --world).

world   4 entities, 3 events
  entity Mary: named, singular, she
  entity apple: common, singular
  entity garden: common, singular
  entity kitchen: common, singular
  event 1: Event go agent=Mary place=kitchen
  event 2: Event pick up agent=Mary patient=apple
  event 3: Event go agent=Mary place=garden

  mary is in the garden
  mary carries apple
  apple is held by mary
  apple has been in: kitchen → garden

World → answer

The question is answered from the world, with its reason: the reason names the apple's holder («apple in mary»), and where the holder is comes from the world's state («mary is in the garden», above), so the apple is in the garden (world babi-probe).

? Where is the apple? → ("garden", "apple in mary")

And back

The world is written back as text. Without its residual, the third sentence comes back with «she» for «Mary»; the residual holds that one item, a 1-bit flag (say the name, which the world has), and with it the world gives every frame back exactly. The tokens, the tree and the frames of these three sentences need no residual (each of their lines above says its sentence back as it was); in longer texts they do, as the table below shows (roundtrip probe).

residual world pron/name: 1 items, 1 bits: agent Mary: the name, where the generator would say «She» (1 bit: a flag)
exact   world + residual → frames: equal
world → «Mary went to the kitchen.» (text «Mary went to the kitchen.»)
world → «She picked up the apple.» (text «She picked up the apple.»)
world → «Then she went to the garden.» (text «Then Mary went to the garden.»)

The way back: world → frames → tree → text

Mova does not only read. Every layer has a decoder that goes the other way: the world is said as frames (a referring-expression generator chooses a name or a pronoun), the frames are realized as a tree (the verb group from the frame's tense, aspect, voice and modality; the roles in their places with their prepositions), the tree is ordered and inflected into tokens, and the tokens are joined into text. Whatever a layer cannot give back is stored beside it as a residual, put in a class (order, punctuation, a pronoun or a name, a dropped word, …) and counted in bits. With every residual, whole books come back byte for byte; that is the gate.

In detail, with every class, gate and control and what the residual asks for next: the autoencoder.

Why it matters. The residual is an honest measure of each layer: what it does not describe shows up as bits, by class, with examples. It ranks the next change to make, and a change that does not shrink the residual has not helped. It also keeps the reader honest: a world that only looks right cannot give its text back.

layerresidual, bits a tokenwhat it is mostly
text ↔ tokens0–0.09line wraps of a book
tokens ↔ tree1.1–5.1word order, typography, contractions
tree ↔ frames6.0–8.6punctuation, words the frames do not keep, order
frames ↔ world1.3–2.1which pronoun, links to frames the world drops

Measured 2026-10-18, a few days before the example above, on five sets (23,586 school lessons, the agreed school treebank (school sentences the parsers and the teacher agreed on, partly the parser's own training data), 41 tale books, the Torah, Alice's Adventures in Wonderland); every volume came back byte for byte, and two runs gave identical reports. Method, classes and the full tables: tools/roundtrip. In the example above, the world needed one item of residual, a 1-bit flag: the name where the generator would say «she». This table has no baseline yet (what a general compressor needs for the same text), so it ranks the layers rather than grading them.

The weakest link. Tree ↔ frames leaves the most behind, 6.0–8.6 bits a token, against 1.1–5.1 for the tree below it and 1.3–2.1 for the world above: the frames keep the events and their roles but not yet the punctuation, the function words around them or their order. By the rule above it is the next target.

Training: a loop

The small models learn round after round (the loop in the diagram; code: tools/cycle):

  1. Drafts. Mova's own small model parses new sentences: the draft tree.
  2. Witnesses. Open neural parsers parse the same sentences.
  3. Agreement. treeagree votes the draft with the witnesses into one agreed tree, with its features and lemmas.
  4. The teacher checks. A large model, as teacher, gets the agreed draft (never a bare sentence) and corrects it; every correction passes the UD gates, and the open parsers check it again.
  5. The parse database. The checked trees join the corpus of agreed trees.
  6. The trainer. The small model is retrained on it (a warm start, every round) and drafts the next round.

Where a large model touches the pipeline. At two points, both in training: as the teacher of trees (step 4 above), and as the teacher of pragmatics, writing silver labels for the pragmatics classifiers, which pass their own gates before anything learns from them. It never answers: at answer time every stage above is Mova's own deterministic code and its trained small models, and the reason given with an answer comes from the world, not from a model's text.

Text → tokens

The text is cut into sentences and tokens, every space and mark kept, and each token gets its lemma, part of speech and features.

takestext: every byte of it

givestokens: the forms, the gap before each, the sentence breaks; each with its lemma, part of speech and features

codeen/src/tok.rs en/src/tag.rs en/src/ptag.rs

Measure: the text back byte for byte from the tokens: 0–0.09 bits a token of residual (2026-10-18); token, sentence-boundary and tagging accuracy not yet reported

Implements 2 · the code stands on it, or tried it

Source of rules / background 2 · hand-written rules and knowledge taken from it, or reading behind a decision

Tokens → tree

Each sentence becomes a dependency tree in the style of Universal Dependencies: who depends on whom, and how. A grammar expert system checks the tree with hand-written rules.

takestokens

givesa Universal Dependencies tree per sentence (CoNLL-U): head and relation of every token

codeen/src/parse.rs en/src/expert.rs gparse

Measure: LAS on held-out treebanks: 85.7 on EWT (the English Web Treebank), 88.5 on the school's agreed test (2026-10-15)

Old grammars as a source of rules. Many of the rules of Mova's grammar expert system come from grammars written between 1851 and 1931 — Brown 1851, Mätzner 1874, Reed 1877, Whitney 1877, Sweet 1891, Poutsma 1904, Jespersen 1914, Poutsma 1921, Jespersen 1924, Kruisinga 1925, Fowler 1926, Curme 1931 — rewritten as checks over Universal Dependencies trees, each with its source, and verified on gold treebanks. It is a rare choice: these books describe English in more detail than any treebank guideline, and what they say can be read, cited and tested.

Implements 3 · the code stands on it, or tried it

Measured against 1 · benchmarks, metrics, scoring conventions, reference results

Source of rules / background 48 · hand-written rules and knowledge taken from it, or reading behind a decision

Background reading: 28 works

Tree → frames

The tree is read into frames: who did what to whom, when, where, why, with the speech act and the VerbNet class; pronouns are resolved to what they stand for.

takestrees, and the discourse so far

givesframes: the event, its verb and VerbNet class, its roles (agent, patient, recipient, place …), tense and modality, the links between clauses; pronouns resolved

codeprag/src/frames.rs prag/src/vn.rs coref

Measure: frame F1 against agreed frames: not yet measured (no agreed frames yet)

Implements 8 · the code stands on it, or tried it

Measured against 8 · benchmarks, metrics, scoring conventions, reference results

Source of rules / background 7 · hand-written rules and knowledge taken from it, or reading behind a decision

Frames → world

The frames of a text become one world: its entities, their states and the events between them.

takesframes

givesthe world: entities by id, and the line of events with roles as ids

codeworld prag/src/roles.rs

Measure: the world's residual: 1.3–2.1 bits a token over five corpora (2026-10-18)

Implements 7 · the code stands on it, or tried it

Source of rules / background 1 · hand-written rules and knowledge taken from it, or reading behind a decision

World → answer

A question is read the same way and answered from the world, with the reason for the answer.

takesthe world, and a question read as a frame

givesan answer, with the reason it holds

codeworld/src/babi.rs world/src/qa.rs qagen math

Measure: the school's tests: 38.8% right of 49 760, four options each, the strongest control (questions shuffled) 29.6% (2026-10-22)

Measured against 6 · benchmarks, metrics, scoring conventions, reference results

Source of rules / background 1 · hand-written rules and knowledge taken from it, or reading behind a decision

Learning

The small models learn in a loop: they draft, open parsers witness, the drafts are agreed, a teacher checks them, and the models retrain on the result. A gain counts only when two runs give identical numbers and it shows on the two-fold check (each half of the training set held out in turn); the test set runs once per release.

takesdrafts of the small models, open parsers, the teacher's corrections

givesagreed trees and labels; retrained models

codetools/cycle tools/treeagree annot gparse train

Measure: how much of the small model's draft the teacher keeps: 98.9 UAS, 98.5 LAS on the newest round of tales (2026-10-23)

Implements 11 · the code stands on it, or tried it

Measured against 1 · benchmarks, metrics, scoring conventions, reference results

Source of rules / background 3 · hand-written rules and knowledge taken from it, or reading behind a decision

And back

The world is written back into text, byte for byte with its residual: what each layer loses is measured.

takesthe world and its residual

givesframes, the tree, the tokens and the text again, byte for byte

codetools/roundtrip en/src/lin.rs en/src/morph.rs tools/translate

Measure: residual bits a token at each layer, in the table below (2026-10-18)

Background reading 9 · hand-written rules and knowledge taken from it, or reading behind a decision

118 works. Every linked title leads to its card on Elamur Research; a «measured» mark leads to what Mova measured with it, on the measured page; «to add» marks a work whose card is not in the library yet.

This page in Markdown → https://md.mova.elamur.ai/free/en/pipeline/