Agentic PrimitivesAP

Example · a translation loop, measured

Translating John 3 from the Greek.
What shaped every verse.

A new American English edition — rbs — drafted from the original-language tokens alone. No English Bible in the drafter's prompt; an ONTOLOGY in it instead: referents, senses, rules and a brief, all held to by checks that are themselves measured. This page is the full account. First the loop as it ran on John 3 (sections 01–06); then the ontology itself — its four boxes and ten layers, and how it generates the skills, is the knowledge base, declares the plan and keys the harness (07–12); then the licence per layer; and at the end a detailed comparison with the scholarly committees, the SIL field stack, Greek Room and Clear, unfoldingWord and the Anselm Project Bible — where we are ahead, where they are, and why the difference is the ontology.

The picture

Six bands. The drafter sees the top three; the harness sees them all.

Read it top to bottom: what the drafter may see and what it may not; the MCP tools that serve it; the skill and the plan with its revise pass; the four checks; the harness — and, in the gutter, the three dashed arrows that carry what the harness found back into the checker, the skill and the knowledge base. The right-hand column is where a verse goes afterwards.

The translation loop: frozen sources and the knowledge base through MCP tools, a skill and a stepped plan with a revise pass, four deterministic checks, and a harness whose floor-and-ceiling runs tune the checker, the skill and the knowledge base — out to a signed edition
The translation loop. Probabilistic steps are the two model calls (draft, revise — rose). Everything else — every tool, every check, every grader but the judge — is deterministic and recorded. The English editions on the top right exist only for the graders; the rbs text on the bottom right was never compared with any of them while it was being written.

01The pieces

Four things touched every verse. None of them was a translation.

The constraint that makes the loop honest is in the first card: the drafter is never shown an English rendering of the passage. Everything that shapes a verse therefore has to come in through the source, the knowledge base, the skill, or the checks — and each of those is something the harness can measure and change.

The frozen sourceswhat the drafter sees

The Hebrew/Aramaic and Greek tokens as the published tables carry them (WLC + NE1904), each with its parsing and Strong's number, frozen under a content commitment; the STEP lexicon entry each number opens; the scripture knowledge base. No English edition of the passage — ever. A runtime test asserts the WEB's wording is absent from the drafter's prompt.

The MCP toolshow it sees them

Five tools on an internal Worker: get_source_tokens, lookup_lexicon, lookup_names, find_similar_approved, run_translation_checks. Each returns the JSON and a one-line-per-item text rendering (`prompt`) that the plan templates straight into the model's prefix — 30k input tokens a chunk fell to 19k when JSON stopped going to the model.

The skill and the planthe order of work

One SKILL.md (translate-from-source) says what the task is, what it covers, what it declines, and which four tools it may call. The orchestration compiles that into a stepped plan — tokens → lexicon → names → similar → draft → checks → revise (only when a check blocks) → final → propose — and records every step as a PROV activity.

The harnesswhat measures it — and what it changed

Experiments over pre-registered case sets, five arms, deterministic graders first and a judge after, paired-bootstrap lifts, a regression suite that plants six kinds of error into the floor. Its first runs blocked two thirds of a real Bible; what it found rewrote the checker's rules, the skill's brief and the knowledge base, each fix as a test.

02The plan, step by step

Ten steps. Two of them think.

This is the plan the model-source-lexicon-memory arm runs for one chunk of eight verses. Every step is a PROV activity with its inputs named; every output is an entity; a guarded step that does not run is a recorded skip. The two model steps are the only probabilistic ones.

tokens tool
get_source_tokens — the frozen tokens for the range: surface, parsing (V-PIA-3S, Prep-b | N-fs), Strong's, position. Variant marks ({TR} ⧼RP⧽ (WH) 〈NE〉) stay on the token so the drafter follows the base text and names the variant.
lexicon tool
lookup_lexicon — one entry per Strong's number: lemma, part of speech, gloss, definition — and, where the knowledge base has one, the concept rule, divine-name convention or unit value attached to that entry. This is where the ontology enters the prompt.
names tool
lookup_names — every name at these verses resolved through the knowledge base to a referent IRI (a TIPNR person or place, a sect, a title), with its decided rendering for this variety when one exists. Simon's son Judas and the patriarch are different IRIs; consistency is bound to the referent, never to an English string.
similar tool
find_similar_approved — approved translations of comparable passages in this edition, as memory. Empty on a new edition; it is what makes the third model arm (model-source-lexicon-memory) differ from the second.
draft model
The drafter (Claude Sonnet 5) reads a cached prefix — the three `prompt` renderings — then the brief and the ask, and returns one entry per verse: the text, and an alignment from EVERY source token to the words that render it ('-' only for an article or marker English carries by construction).
checks tool
run_translation_checks — four blocking checks (source coverage, negation, names through the KB, quantities) plus chrF against each reference edition, reported per edition and never pooled. The draft is scored against the source it came from, not against a translation.
revise model · guarded
Runs only when checks.blocking > 0 (a Step.when guard — a skipped step is a recorded skip with a null output). Same cached prefix, the draft and its failing checks, and an instruction per check kind. The tool description is byte-identical to the draft's so the cache hits. Clean chunks went from 1 of 6 to 6 of 6 on Jonah.
checks2 · final · finalChecks tool
The revision is checked; local.coalesce picks the revision when it exists and the first draft otherwise, and the proposal carries whichever checks ran last.
propose tool
One proposal per verse into the rbs edition store: text, alignments, checks, arm, and the run reference stamped on it — so an export can tell a driver run from a Lab run that planted an error on purpose.
answer answer
The proposal, back to the caller. The whole run — intent, plan, activities, entities, usage including cache reads and writes, models, checks, answer — is one PROV record on disk outside every repository. The words never enter the evaluations folder; results there are numbers and verdicts only.
The prompt is text, not JSON. get_source_tokens, lookup_lexicon and lookup_names each return a prompt rendering — one line per token, lexeme or name, cantillation stripped — and the plan templates those into a cached prefix. The model never parses a structure to find a gloss.

03The ontology in the text

Two layers of the knowledge base reached the drafter in John 3. Both are visible in the verses.

The scripture knowledge base is an A-box, not a glossary: 3,129 persons, 1,007 places, 5,169 key terms, 50 theological concepts whose definition IS the rendering rule, 16 divine names each with a convention, and — since October 17 — three divine persons the names are forms of. The lexicon tool attaches a concept's rule to the Strong's entry it governs; the names tool resolves a token to a referent and its decided rendering. Here is where each one shows in the chapter.

G4151 πνεῦμα
Rule: the referent decides the capital: Spirit / spirit / wind — John 3:8 plays on both. Visible at 3:5–6 “born of water and the Spirit… born of the Spirit is spirit” and 3:8 “The wind blows… born of the Spirit” — the three-way split the rule names, in one passage.
skb:concept-spirit · scr:TheologicalConcept
G5207 + G444 υἱὸς τοῦ ἀνθρώπου
Rule: “Son of Man” as the title in the Gospels; lower-case for the Hebrew idiom. 3:13, 3:14 read Son of Man — the title, not “son of man”.
skb:concept-son-of-man
G4561 σάρξ
Rule: “Flesh” where the theological sense is in view; “body” only where the text means meat or mortality plainly. 3:6 “born of the flesh is flesh” — not “body”.
skb:concept-flesh
G932 βασιλεία
Rule: “Kingdom” throughout. 3:3, 3:5 kingdom of God.
skb:concept-kingdom-of-god
G2920 / G2919 κρίσις / κρίνω
Rule: “judgment” where God’s verdict is; never “righteousness”. 3:19 “this is the judgment” (where a translator working from memory might reach for “condemnation”).
skb:concept-justice
G166 + G2222 ζωὴ αἰώνιος
Rule: “Eternal life” throughout John and the letters; “everlasting” only in the Old Testament’s “everlasting covenant”. 3:15, 3:16, 3:36 eternal life — no “everlasting”.
skb:concept-eternal-life
G5547 Χριστός
Convention: “Christ” throughout the New Testament; “the Messiah” where the article carries a title, footnoted. 3:28 “I am not the Christ”.
skb:divinename-christos · btr:NameRendering decision-names-amer-v1
G4100 πιστεύω
Rule: “faith” and “believe” for the Greek; “faithfulness” where the text means reliability. 3:15, 16, 18, 36 believe.
skb:concept-faith
G907 βαπτίζω
Rule: transliterate — “baptize”, never “immerse” in the running text. 3:22–23, 26 baptizing.
skb:concept-baptism
G2316 θεός
Convention: “God” of the true God; “god” / “gods” of others. Every God in the chapter — and this one is checked, not only advised: the names check holds the draft to the decided rendering of the referent.
skb:divinename-theos · btr:NameRendering decision-names-amer-v1

Names resolved to referents

Each of these was resolved through the knowledge base to its TIPNR IRI (an at:Person, an at:Location, a scr:NamedThing), so the check holds the draft to the referent's rendering rather than to a spelling: the Judas who was Simon's son is one IRI in all four Gospels, and the patriarch is another.

JesusNicodemusMosesJohnIsraelJudah / JudeaJordanAenonSalimPhariseeRabbi

Four btr:NameRendering decisions were enforced, not advised: God, Jesus, Christ, Holy Spirit (decision-names-amer-v1). One unit (G5438 φυλακή “watch of the night”, with its approximate value) also reached the prompt and went unused.

A caveat on causality. The rules were in the prompt and the text conforms; that is what this page can show. Whether a drafter without the lexicon and the knowledge base would have written “wind” at 3:8 and “judgment” at 3:19 is a counterfactual the harness is built to answer — the model-src arm over the same chapter, about $0.80 — and has not yet been run on John 3.

04The harness plan

Seven steps, in the order they have to happen.

A harness is a plan before it is a tool. This one freezes what it measures, pre-registers what it will measure it against, sets a floor and a ceiling, grades deterministically before it asks a judge, reads the floor and ceiling before it reads the model, pilots before it drives — and only then publishes under an issuer.

1 · Freeze the sources
Ingest the token tables, the lexicon subset and the reference editions once, under content commitments the MCP refuses to re-ingest if the upstream revision moved. A benchmark against a moving source is not a benchmark.
ingest-sources.mts · /admin/segments refuses a moved revision
2 · Pre-register the sets
A dev set (55 cases) to tune on, a regression set (580 planted errors, six kinds) that measures the checker and is never pooled with a capability set, and a held-out set written ONCE and locked. A set says task: translate; a localise arm on it is refused.
suiteKind: capability | regression · held-out: locked
3 · Set the floor and the ceiling
control-web runs the WEB through the checker as the ceiling (its chrF against itself excluded). gloss renders the tables' glosses in gloss order with one alignment per token — the floor, and pure, so the regression suite can plant its errors in the same text and know exactly what it planted.
arms: control-web · gloss · model-src · model-lex · model-mem
4 · Run the deterministic graders first
scope, fidelity-checks (the same four checks the plan runs), source-coverage, perturbation-catch, chrF per reference edition. A judge grader (fidelity) sees the WEB as a flagged reference, and reads cantTell — out of the agent's denominator — when its key is absent. A run with no verdict carries a failureCause: agent, grader or environment; only agent counts against the agent.
ALL_GRADERS — one list; the one-run path once had its own
5 · Read the floor and the ceiling before reading the model
If the checker blocks the WEB, the checker is wrong, not the WEB. Tune on dev until both read ~0.99; re-run regression to see what the tuning cost in catch rate; then — and only then — run the model arms, and quote held-out alone.
tr-dev-local-2 → -3 · tr-regression-local-3
6 · Pilot, then drive
A whole-Bible driver walks the source chapter by chapter in chunks of eight verses with a ledger and a resume; a pilot over small books (Jonah, Ruth, Philemon, Jude, Obadiah, 2–3 John: 231 verses) set the revise pass, the text prompts, prompt caching and the D1 bind limit before a dollar went on a long book. Then one chapter: John 3.
translate-bible.mts --chapters John.3
7 · Publish under an issuer
Export picks one proposal per verse (approved > not rejected > fewer blocking > later), from driver runs only; a service agent chartered by the scripture steward signs every verse descriptor with a key it holds only as a delegate. The edition carries no Berean name.
rbs-bible.svc · AKCS content-signer key · ERC-7710 leaf

05What the harness changed

The harness did not grade the translation. It rewrote the rules the translation was held to.

Each of these is a measurement that disagreed with a text the measurement had no business failing — the WEB, the floor, a Jonah chunk, two verses of John 3 — and a rule that changed as a result, with a test so it cannot drift back. The skill's text, the checker, and the knowledge base are the three things it reached.

0.99
fidelity-checks on the ceiling and the floor
was: 67% / 80% blocked
0.94
regression catch rate
580 planted errors · was 0.90
6 / 6
Jonah chunks clean with revise
was 1 / 6 on a single draft
36 / 36
John 3 verses clean
two checker gaps found and fixed · $0.77
The checker blocked the Bible
First dev run: 67% of the WEB (the ceiling) and 80% of the floor failed a blocking check. Five rules were wrong, not the texts: curly apostrophes (don’t ≠ don't); one `not` demanded per negator where English distributes one over “or” and οὐ μή is one negation; numbers that did not compose (“fourteenth” is 4 + 10, “three hundred” 3 × 100); divine-name claims by a Strong's that is also a common noun (πνεῦμα in “poor in spirit”, עֶלְיוֹן “upper pool”); “dropped content tokens” that were conjunctions and prepositions English absorbs.
fidelity-checks: control-web 0.99 · gloss 0.99 after · blocking rate 0.09 / 0.24
The regression suite priced the fix
Freeing pronoun drops raised catch 0.90 → 0.94 overall (added-clause 0.76 → 0.99, dropped-clause 0.92 → 0.97) and cost changed-name 1.00 → 0.91 and swapped-speaker 0.99 → 0.90. The suite exists so that a rule loosened for the ceiling shows what it stopped catching.
tr-regression-local-3 · 580 runs · per kind, never pooled
The pilot changed the plan
Jonah: 1 of 6 chunks clean on a single draft; 6 of 6 with a guarded revise pass that hands the model its draft and the failing checks. Prefixed waw read as a dropped token until `Conj-w | V-…` was parsed as the verb it is; נָא and לֵאמֹר-as-infinitive became free; numeral runs compose under + and × in any bracketing; a hyphenated compound reads as its parts. Jude's sentences carried more Strong's numbers than D1 allows binds, so every IN (…) is paged.
5 lessons in the driver's record; each a test
John 3 found two more
Two chunks still blocked after revise. 3:4 — δεύτερον is glossed “secondly”, so “a second time” read as a number the source did not have; the quantities check now reads an ordinal adverb as its number. 3:13 — εἰ μή is exceptive, and the negation check wanted a `not` for a μή the draft had rightly rendered “except”; a negator after εἰ / ἐάν rendered except / unless is carried. Both drafts were right; both rules were wrong; both are tests; the chapter re-ran to 36 of 36.
John.3.1-8 blocking 2 → 0 · John.3.9-16 blocking 1 → 0 · $0.77
The prompt got cheaper without getting shorter
JSON out of the model's context (the tools render a `prompt` line per item): 30k → 19k input tokens a chunk. The system and the passage prefix marked ephemeral for caching; the revision reads the draft's prefix from cache — once the tool description was made identical across the two calls (tools precede the system in the cache key). Cache reads and writes are on the usage line of every record.
$0.012–0.023 a verse on Claude Sonnet 5 · whole Bible ≈ $650

06The result

John 3:16, from the Greek.

Twenty-five tokens, twenty-five alignments, one negator carried, θεός rendered by convention and ζωὴ αἰώνιος by the knowledge base's rule. No reference edition was consulted while it was written; the graders compared it with four afterwards.

rbsRichard Bible Standard · en-US · from NE1904

For God so loved the world that he gave his one and only Son, so that everyone who believes in him should not perish but have eternal life.

source-coverage 25/25 · negation 1 carried · names: θεός → “God” (conventional) · quantities: none in the source · issuer rbs-bible.svc

BSBBerean Standard Bible · a grader's reference, never the drafter's

For God so loved the world that He gave His one and only Son, that everyone who believes in Him shall not perish but have eternal life.

Where they differ is where a rule or a reading decided: rbs does not capitalise deity pronouns, renders ἵνα “so that”, and μὴ ἀπόληται “should not perish”. Where they agree, the same Greek produced the same English twice, independently.

The edition is served by the Scripture service as rbs, public domain, one signed descriptor per verse, verifiable against the corpus root — and under an issuer of its own (rbs-bible.svc, chartered by the scripture steward), because a derived edition does not carry the Berean name. John 3 is the first chapter; the rest of the Bible is a decision about spend (≈ $650 at the pilot's rate), not about method.

07The ontology, in full

Four boxes, ten layers. The translation is held to all of them.

An ontology here is not documentation. It is the single source from which the skills, the knowledge base, the plan and the harness are generated or validated, so that a rule written once holds in all four places and a change in one is a measured change in the others. Read the four boxes first — what kinds of knowledge the ontology carries — then the ten layers, top to bottom, from the foundations the whole substrate shares to the translation domain and its two A-boxes.

T-box — the classes
What kinds of thing exist and how they nest: a scr:DivinePerson is an at:Agent and a scr:Referent and NOT a scr:SupernaturalBeing (a sibling, deliberately — Baal is a being of the narrative; God is not classified beside him). A btr:ReferentResolution is an at:Observation. Preflight refuses a class that reaches no upper anchor, and a class in no semantic cluster, because a class nobody can see is a class nobody uses.
owl:Class · rdfs:subClassOf · at:inSemanticCluster
R-box — the relations and their logic
Inverses the loaders materialise (a segment hasTranslation ↔ a translation ofSegment), a transitive ancestor chain over parent, functional fields (one check kind, one severity, one verdict, one brief digest), a property chain (a translation's source edition is its segment's), and disjointness over editions, record kinds and vocabulary schemes. Reasoned over in preflight with an OWL-RL closure — fourteen competency-question fixtures must hold — and never in the store, which stays inference-off after a corrupt closure once wedged every write.
owl:inverseOf · TransitiveProperty · FunctionalProperty · propertyChainAxiom · AllDisjointClasses · scripts/reason_ontology.py
C-box — the controlled values
Twenty closed lists in bible-translation alone: check kinds, severities, verdicts, statuses, genres, difficulty tags, perturbation kinds, arm kinds, task kinds, resolution methods. Each value is `skos:inScheme` + `skos:notation`. They are the SOURCE of every TypeScript union in the harness and the MCP: a literal the code uses that is not a notation fails the build. The day the check was written it found two drifts nobody had noticed.
skos:inScheme · skos:notation · scripts/project_vocabularies.py --check
A-box — the referents
The individuals: Aaron, Capernaum, the tribe of Levi, the Holy Spirit, ἀγαπάω, the concept Covenant, the cubit, the event "Jesus walks on water". ONE node each, with its source-language forms, its attestations, its authority cross-references (TIPNR, Theographic, Wikidata, Pleiades), and — per target language — its renderings. The translation is held to these nodes, never to an English spelling.
skb: skx: · 238k triples across two graphs
DOLCE + DnS
The upper distinction the whole design rests on: a DESCRIPTION (a norm, a brief, a plan — what should hold) against a SITUATION (what a run claims did hold). A translation brief is a dul:Norm; a run is an at:Situation that satisfies or fails it. Without this split a policy and an outcome are the same kind of thing and nothing can be measured against anything.
dul: · ontology/upper/dolce.ttl (generated subset, 37 classes, 74 axioms)
PROV-O
Every step of a run is a prov:Activity, every input and output a prov:Entity, every model and tool a prov:Agent. The run record the orchestration writes IS a PROV document, so "which model, which prompt version, which tool outputs, which checks" is a graph query, not a log search.
prov: · RunRecorder emits prov:Activity / prov:Entity / wasDerivedFrom
P-Plan + EP-Plan
A plan is a p-plan:Plan of p-plan:Steps with Variables; EP-Plan adds Constraints and Objectives a step must satisfy. This is where "the drafter never sees English" stops being a sentence in a brief and becomes a typed constraint on the inputs of one step — checkable before a run and auditable after it.
p-plan: ep-plan: · btr:TranslationPlan ⊑ at:Plan ⊑ p-plan:Plan (declared; the TypeScript plan is validated against it)
agentic-trust (at:)
The substrate's own base: Agent, Capability, Skill, Archetype, Plan, Observation, AssessmentResult, Category, ContentCommitment. A skill REALIZES a capability; a capability has a dotted id the registry keys on; an archetype is compiled from the skills attached to it. Every translation class reaches one of these — that is what lets the same Lab, the same record checker and the same registry run a translation agent and a grant-writing agent alike.
at: · 1.3.0, CHANGELOG, tagged
faith · publishing · commerce
The church today (people groups, bodies), the corpus model (a release carries a snapshot root; a verse text is a content revision with a commitment), and licence-as-offer. Scripture specialises these rather than re-minting them: an edition is a pub:CorpusRelease, an apostolic body is faith's ekklesia.
gc: fci: pub: cc:
scripture (scr:)
The text as a graph: loci, editions, the narrative (27 kinds of event, the Searle split of speech acts, roles, places, lineages, collectives), attestation ("an entity is never asserted true; it is attested in verses by named sources"), and the knowledge-base classes — key term, concept, divine name, divine person, unit, festival, membership — under one abstract root, scr:Referent.
scr: · 1.1.0 · 120+ classes, 24+ shapes, the first R-box
the knowledge base (skb:)
The A-box: 3,129 persons with kinship and period, 1,007 places (870 geocoded), 39 supernatural beings, 50 named things, 5,169 key terms, 50 concepts, 16 divine names on 3 divine persons, 34 units — 177k triples, generated from CC BY scholarship (TIPNR, OpenBible, STEP) plus curated rules, in its own named graph.
urn:skills:context:scripture:kb · ontology/scripture.kb/*.ttl
the explorer snapshot (skx:)
A second A-box under its own licence: 477 narrative events with participants, places, years and 56k attesting verses; 78 collectives; 843 memberships with roles; and a 3,000-row crosswalk that puts the explorer's canonical id on the knowledge base's own referents. Theographic is share-alike, so this graph is kept apart from the CC BY one and the join between them is a cross-reference, not a merge.
urn:skills:context:scripture:kb-sa · CC BY-SA 4.0 · built from the explorer's database export
english-varieties (eng:) → language varieties
What a target VARIETY is and what a change between two of them is: spelling rules, lexical correspondences by sense, constructions with a permission, punctuation, register, the style profile that binds them. The rules engine's JSON is a projection of this file. Being lifted to a language-neutral layer so Arabic is a sibling of English, not a tenant.
eng: 1.0.0 · lv: planned (O4a)
bible-translation (btr:)
The translation domain: source and target editions, segments and tokens, alignments, senses and renderings, the brief, runs, checks (with kind, severity, verdict), critique, blind review, benchmark passages, perturbations, arms — and since October 17 the referent resolution and one rendering class over the whole spine. Twenty vocabularies; every enum in the code is a projection of them.
btr: 1.1.0 · 55 classes, 36 shapes, 20 vocabularies
The dependency runs ONE WAY, top to bottom. A lower layer may reach up; nothing reaches down. A translation class with no path to a foundation is a preflight failure; a class in no semantic cluster is refused because nothing would draw it. The three foundations are generated subsets of the publishers' own files, narrowed to the terms this repository references and regenerated, never hand-edited.

08Ontology → skill

The skills are generated from the ontology. The ontology is not described by the skills.

A SKILL.md is the text a model reads to do one job. Here it is also a contract: which capability it realizes, which classes it covers and excludes, which tools it may call, and — generated from the SHACL shapes — exactly which typed record the run must leave. The same shapes validate the record afterwards. Promise and check cannot disagree because they have one source.

The capability id and the classes a skill covers
A SKILL.md's frontmatter names its capability (btr.translate.draft, btr.referents.resolve — dotted ids the registry keys on), the classes it covers and the classes it excludes. The data graph restates the same capability IRI with the classes the skill PRODUCES and CONSUMES; preflight holds the two to each other. The archetype (the Translation Agent) is COMPILED from the skills attached to it — a definition whose tools have only an id and a description is the sign of a broken join, not of a thin agent.
skills/bible-translation/*/SKILL.md · ontology/bible-translation.data.ttl · register-bible-translation.mjs
The record section is generated from the shapes
Every writer skill ends with "The record this run produces": one object per produced class, its required fields, its optional fields, the controlled values allowed — written by a script from the SHACL shape, not by hand. Change the shape, regenerate, and the body changes; a body the ontology has moved past fails preflight. The harness validates the record a run leaves against the SAME shape, so what the skill promises and what the state check demands cannot disagree.
scripts/gen_record_sections.py --domain bible-translation · the state check
A new skill in an hour
resolve-referents, written October 17: a class (btr:ReferentResolution), a shape with a required field, a vocabulary (resolution method), a capability row, a producesClass row, the body — and the record section appeared, the registry took the capability, the archetype gained a twelfth tool. The runtime step that calls it is the next piece; the contract it will be held to already exists.
skill:bible-translation/resolve-referents · version 1
What a skill may not do is in the ontology too
The brief is a dul:Norm with typed fields (textual-basis policy, gender-language policy, group-name policy, deity-pronoun policy, recall policy, what is shown to and hidden from the drafter) and a digest. The skill text and the data graph state the same fields, so the policy register — the document a theologian reads — is generated from the graph rather than maintained beside it.
btr:TranslationBrief · ex:brief-amer-v1 · policy-register.md

09Ontology → knowledge base

The knowledge base is the A-box. Consistency is bound to the referent, never to a word.

Two graphs, two licences, one spine. The CC BY knowledge base holds every person, place, being, key term, concept, divine name and unit the frozen source needs; the CC BY-SA explorer snapshot holds the events, collectives and memberships Theographic contributed, joined to the first by a crosswalk of cross-references. Both are generated from their sources and checked for drift; the curated parts — concept rules, divine persons, realia — are hand-authored and cited.

3,129
persons with kinship and period
TIPNR · CC BY · 5,535 name forms
477
narrative events with participants, places, years
explorer snapshot · CC BY-SA · 56k attesting verses
3,000
crosswalk rows — one referent, two authority ids
joined by name + Strong's, name + reference, or verse overlap
73.9%
of John's content tokens reach only a gloss
the backlog the coverage report names, per semantic domain
Consistency is bound to the referent
"Judas" names six men; "Joshua" and "Jesus" are one Greek word; "love" is three. A string cannot carry consistency across a Bible. A TIPNR IRI can: the names tool resolves a token AT THIS REFERENCE to skb:person-Judas_Mat.10.4-Act, the rendering is a row on that node, and the names check holds the draft to the node. A new target language adds rows and never adds nodes.
btr:NameRendering = referent × variety × text × policy × decision
God, the Son, the Holy Spirit are nodes; the names are forms
Until October 17 the knowledge base had sixteen divine NAME forms with conventions and no referent behind them. Now יהוה, אֱלֹהִים, אֵל, שַׁדַּי, θεός are forms of one node (skb:divine-god); Ἰησοῦς and Χριστός of another, the same node as TIPNR's person Jesus; πνεῦμα ἅγιον of a third. κύριος is a form of two and the verse decides. A rendering may be keyed to referent AND form, because יהוה → "the LORD" and אֱלֹהִים → "God" are two renderings of one referent. The Trinity is a concept rule on the three nodes, never a word inserted in the text.
scr:DivinePerson · scr:formOf · btr:forNameForm · skb:concept-trinity
Every aspect, not a list of kinds
People, places, collectives, events, speech acts, offices, realia, time, lexemes, concepts, textual variants, pericopes — all kinds of one abstract scr:Referent, all rendered by one mechanism. The guarantee is not the list but a NUMBER: every content token of the frozen source carries a Strong's number and every number is a key term (100% lexical coverage by construction); how many reach a decided rendering, a sense or a concept rule above the gloss is measured per book and per semantic domain. John today: 3,067 content tokens — 7.3% referent-rendered, 6.6% referent reached without a rendering yet, 12.2% under a concept rule or convention, 73.9% gloss only. That last number is the backlog, worked per domain before a book is drafted.
scripts/referent-coverage-report.py John · 22 semantic domains
The explorer is the system of record for events and collectives
The Bible explorer at explorer.faithnet.io had already reconciled Theographic's 450 events, 78 organisations and 843 memberships onto TIPNR and OpenBible — the two sources the knowledge base is built from — and recorded the TIPNR id of each node. So the join exists; it is now a 3,000-row crosswalk of authority cross-references on the knowledge base's IRIs, with the explorer's own match confidence carried through. One referent, two authority ids; two licences, two graphs, one cross-reference between them.
ontology/scripture.kb-sa · explorer.faithnet.io · scripts/build_scripture_explorer_graph.py
Evidence, never authority
The scripture graph's own scope note: an entity is never asserted true, it is attested in verses by named sources. Every knowledge-base record carries where it came from (dataset, licence, confidence, method); a generated event, when Theographic has none for a pericope, is proposed by a model, read blind by a second model family, and signed by a person before a drafter or a check may read it.
scr:SourceAttestation · scr:AuthorityXref · scr:matchMethod

10Ontology → plan

The plan is a declared artefact. Its constraints are the invariants.

A plan of steps with typed inputs, outputs, guards and constraints is a P-Plan with EP-Plan constraints — the same vocabulary the foundations layer provides. Declaring the translate plan in it turns the loop's invariants from prose into things a validator checks before a run and a grader reads after one, and makes the plan identical across target languages by construction.

The plan is declared, not hand-coded
Today the translate plan is 366 lines of TypeScript and "the drafter never sees English" is a comment, a test and a sentence in the brief. In the ontology it is a btr:TranslationPlan of typed steps with EP-Plan constraints: step `draft` may take no input typed btr:ReferenceEdition or btr:TextSegment of the BSB. The TypeScript plan becomes a PROJECTION validated against the graph — same tools, same inputs, same guards — and the invariant becomes something a grader can read off the run record rather than trust.
btr:TranslationPlan ⊑ p-plan:Plan · btr:StepConstraint ⊑ ep-plan:Constraint · scripts/project-plan --check (O4b)
Language changes the rows, not the plan
A second target language changes btr:targetVariety, the brief and the style profile. The plan graph — tokens → lexicon → names → referents → draft → checks → revise → critic → propose — is unchanged, and so are the constraints. That is what "consistent regardless of language" means in practice: the Arabic edition runs the same declared plan against the same referents with different rendering rows.
btr:targetVariety · lv:Variety (planned)
The referent pass is a step with a record
Before the draft step, every name, divine name, key term and quotation of a pericope is resolved to its node — method and confidence per token, unresolved tokens listed, never guessed. The drafter is shown the resolutions as text; the names and speaker checks read them; the sheet of a book's resolutions is what a reviewer signs. A model-proposed resolution under the brief's threshold is "cannot tell" to the checks: out of the denominator, in the reviewer's queue, never a silent pass.
btr:ReferentResolution · resolve-referents · invariant 10
Every step is a PROV activity, so behaviour is gradable
The run record names each step, its inputs, its outputs and its usage (cache reads and writes included). With the plan graph beside it a grader can ask "did the referent step run before the draft", "did any step input carry an English edition", "did a blocking check lead to a revise", "is the critic a different model family", "does every lexicon fact the draft cites appear in a tool output of this run" — a behaviour suite over the trajectory, kept apart from the capability numbers.
p-plan:correspondsToStep · suiteKind: behaviour (H2)
State of play. The referent-resolution class, vocabulary, skill and capability exist and are registered; the plan graph and the runtime step that executes it are the next pieces on each side. Until the plan graph lands, the TypeScript plan is the plan and a runtime test asserts the invariant; after it, the invariant is a constraint the graph carries and the code is validated against.

11Ontology → harness

The harness is keyed to the ontology. Every number says which layer it measures.

A harness that reports one score tells you nothing about what to change. This one maps graders to the skill, knowledge-base file or ontology layer they measure, draws its perturbation kinds and difficulty tags and arm kinds from the controlled vocabularies, validates a run's records against the shapes the skills were generated from, and closes the loop: a finding names an ontology element, a release regenerates every projection, and the same pre-registered set accepts or reverts it.

Graders are keyed to the layer they measure
A map says which graders move when which skill, knowledge-base file or ontology layer changes: source-coverage and recall-independence for the drafter skill, fidelity-checks for the brief, perturbation-catch for the checker, fidelity-judge for the concept rules. A change to one thing runs the same pre-registered set before and after; the report names the layer. The map itself becomes a projection of the ontology (btr:measuresCapability).
evaluations/bible-translation/skill-graders.json · skill-performance-report.mts --diff
Perturbation kinds, difficulty tags and arm kinds are C-box values
The regression suite plants errors of nine kinds; the benchmark stratifies by genre and difficulty; the arms are pre-registered kinds. All three are controlled vocabularies in the ontology, and the code's unions are held to them. The suite that measures the checker and the sets that measure the model are never pooled — the vocabulary says which is which (suiteKind: capability | regression | behaviour).
btr:PerturbationKind · btr:DifficultyTag · btr:ArmKind · btr:TaskKind
Acceptance conditions per case are typed
The next grader: an expert attaches to a hard passage conditions of a controlled kind — preserve-negation, preserve-agent-patient, retain-ambiguity, no-explanatory-insertion, preserve-referent, render-concept — each saying which checker is competent to judge it: code (compiled to a scoped deterministic grader), judge (a rubric criterion) or human. The number a scholar can read is "38 of 40 difficult passages met every expert condition", not "8/10".
btr:AcceptanceCondition ⊑ dul:Norm · btr:conditionKind (H1)
The record is what gets graded
A run leaves typed records (a translation, its alignments, its checks, its referent resolutions) and the state check validates them against the shapes the skill was generated from. An answer with no record is absent, not partially right; a record from a previous run is stale, not a pass. Every number says its set, its version, its arm, its judge model and its denominator; a run with no verdict carries a failure cause, and only the agent's own failures count against the agent.
outcome-per-class · failureCause: agent | grader | environment · judge tier named
The floor and the ceiling come first
Before any model is measured, the checker is: a public-domain human translation runs through it as the ceiling, the interlinear gloss as the floor. The first dev run blocked 67% of the ceiling — five rules were wrong, not the Bible. After tuning both read 0.99, and the regression suite priced what the tuning cost in catch rate (0.90 → 0.94 overall; two kinds fell). A checker whose precision and recall are unmeasured is an opinion.
control-web · gloss · tr-dev-local-3 · tr-regression-local-3
The improvement loop closes through the ontology
A finding (a reviewer's verdict, a check failure, a judge disagreement, a recall hit) names the ontology element it concerns; the change ships as a versioned release with a changelog; the release regenerates every projection — skill bodies, rules JSON, knowledge-base projection, vocabularies, plan, grader map; the measurement that accepts it is the same set before and after. Weekly while a book is in translation. A release with no measurement is not a release.
oe:ReviewFinding · CHANGELOG per context · scripts/check_ontology_release.py

12Open throughout

Open source from the text to the T-box, with the one share-alike graph kept apart.

The edition and everything that produces it are open. The inputs are public domain and attribution-only, so the text and the ontology stay attribution-only too; Theographic's share-alike data lives in its own graph with its own licence file and is consulted, not merged; code is Apache-2.0; every dependency is pinned in a manifest that fails the build when a licence is outside the policy.

The rbs text, footnotes, release records
CC BY 4.0 (or CC0, the custodian's call). The inputs are public domain (the Berean tables, WLC, Nestle 1904) and CC BY (STEP, TIPNR, OpenBible, Macula); a copyleft text would add a condition none of them carry.
a derived edition never carries the Berean name
Ontology, knowledge base, plans, benchmark sets
CC BY 4.0 — redistributable, remixable into any downstream ontology.
ontology/scripture.kb · ontology/*.ttl
The explorer snapshot
CC BY-SA 4.0, Theographic's terms — an open licence; it only requires that this graph and derivatives of it stay under it. Separate files, separate named graph, separate manifest entry; a run consults it and records what it read, and a verse rendered with its help reproduces none of its expression.
ontology/scripture.kb-sa/LICENSE.md
Code
Apache-2.0 (the skills already carry it); model weights and metric models only under Apache-2.0 or MIT, pinned by exact revision in the manifest. A dependency outside the policy fails the build.
docs/bible-translation/manifest.json · check-translation-manifest

13The field

How this differs from the leading translation efforts — in detail, and honestly.

What exists, as each project publishes it (read on 17 October 2026; nothing here is copied from any of them). For each class of effort: what they do, what we do differently, and in both directions what the other is ahead on. The through-line is the same in every row: where they hold their decisions as documents and their consistency as strings, we hold them as an ontology a machine is measured against and a second project can import.

Scholarly committeesNIV (CBT), ESV, CSB, NASB 2020 / LSB, NRSVue, NLT, NET

What they do

The gold standard of the craft: a decided critical text (BHS/BHQ, NA28/UBS5), scholars per book in two or three tiers of review, full lexica and discourse analysis, key-term lists and style sheets maintained by the committee, Paratext's biblical-terms and parallel-passage tools, a preface that states the philosophy. NET publishes 60,000 translator notes. The process is the review; nothing ships without it.

What we do differently

We take the committee's DISCIPLINE and make it machine-checkable: the key-term list is a graph of referents and senses with a rendering per language; the style sheet is a typed brief with a digest; the parallel-passage tool is a grader over groups the benchmark already keeps; every rendering decision is a record with a model, a prompt version and a reviewer. What a committee holds in its members' heads and its minutes, the ontology holds as data a run is measured against. What we lack is exactly their strength: no verse has yet passed a human exegete, and the textual basis is declared (Nestle 1904 as the tables carry it) rather than decided unit by unit. Both are open items with a path (the blind review queue; the 1,759-unit textual ledger).

Who is ahead on what. Ahead of us: human exegetical review, a decided critical text, discourse analysis, readability testing. Behind us: nothing of theirs is reproducible by a second party from the published artefacts; ours is, verse by verse, from frozen commitments.

Open small-team editionsBSB (Bible Hub), WEB, LEB, OEB

What they do

Public-domain or open texts made by a small team or one editor with volunteers; the BSB publishes its interlinear tables with eight editions' variant marks, which is the single most useful open artefact in the field — and the frozen source our tokens come from. Light textual criticism; interlinear-driven consistency; minimal automated checking.

What we do differently

We stand on the BSB's tables and freeze them under content commitments; the gloss they carry is our FLOOR (the arm every model arm must beat), never a source the drafter sees. Where the BSB's consistency is interlinear and a team's eye, ours is a referent graph and a measured check; where its variant marks are footnotes, ours are a ledger of typed textual decisions awaiting sign-off. The licence shape is the same (public domain / CC BY) and deliberately so.

Who is ahead on what. Ahead of us: a complete, published, human-read Bible. Behind us: no provenance beyond the team's word; no measured checker.

The field-translation AI stackSIL Serval (NLLB-200 fine-tuned per project), Scripture Forge (400+ projects), AQuA, Lynx, Paratext

What they do

The stack that serves actual minority-language translation: an NMT model fine-tuned on a project's own ~8,000 translated verses drafts the next book; AQuA assesses drafts (missing words, semantic similarity to a reference, naturalness outliers) and gives reviewers heat maps; Paratext runs the biblical-terms and consistency checks; FOBAI's process requires team, consultant and community review. SIL's own line: "all drafts contain errors". Serval is open source; project data stays with the project.

What we do differently

Different problem, same values. Serval learns the target language from the team's own verses; we translate from the original into a language the model already knows, so our risk is the opposite one — RECITATION of published editions, which we measure (John 3 overlapped the BSB at 0.56 where BSB and WEB overlap each other at 0.33) and gate. Where AQuA compares a draft to a reference, our checks compare it to the SOURCE TOKENS it came from (coverage, negation, names through the referent graph, quantities) and the references are graders' instruments only. Where Paratext's biblical terms are strings per project, ours are referents and senses shared across every edition. The reviewer dashboard AQuA has is on our list; the measured checker precision and recall we publish is not on theirs.

Who is ahead on what. Ahead of us: deployment to hundreds of real teams, consultant review, community testing — the whole human process. Behind us: the checker's own false-positive and catch rates are not published; evaluation sets are not pre-registered and locked.

Checking toolsGreek Room (USC-ISI / ETEN), Clear.Bible — Macula syntax trees, manually corrected alignments, speaker-quotations

What they do

The best open checking machinery in the field: spelling by phonetic similarity and alignment, terminology consistency, omissions, names, quantities, parallel passages, character-set checks (Greek Room); morphology, syntax trees, semantic roles, gold alignments and speaker-quotation spans for the whole Bible under CC BY (Clear). Built for reviewers of human translations.

What we do differently

Clear's data is where our next layers come from: Macula's domain and frame fields for senses (so πνεῦμα "wind" and "Spirit" become two senses, not one number), speaker-quotation spans for the speaker check and the referent pass, gold alignments to score the drafter's self-reported alignments. Greek Room's checks and ours overlap on names, quantities and consistency; the difference is that ours run INSIDE the loop (a blocking failure sends the draft back before anyone sees it) and are themselves scored on a floor, a ceiling and a planted-error suite on every change. Theirs are for a reviewer; ours are for the reviewer and for the model, and are measured.

Who is ahead on what. Ahead of us: syntax trees and gold alignments in the drafter's context and the grader (planned, CC BY). Behind us: no numbers on their own checks' precision; no loop.

Open components ecosystemunfoldingWord ULT/UST, Translation Words / Notes / Questions, Door43

What they do

Gateway-language literal and simplified editions plus per-verse notes and per-term articles, so church-based teams can translate with helps; alignment-based checking in translationCore; checking levels 1–3. Everything CC BY-SA.

What we do differently

Translation Words is the closest thing in the field to our key-term and concept layer — about a thousand articles on terms, names and realia — and share-alike, so it goes beside Theographic in the separately licensed graph, consulted and cited, never merged into the CC BY knowledge base or the text. Our concept rules differ in kind: each is a RENDERING RULE for one edition with a rationale and a lexicon citation, bound to Strong's numbers (and soon senses) the checker can hold a draft to; theirs are explanations for a human translator. Both are needed; ours is the one a machine is measured against.

Who is ahead on what. Ahead of us: breadth of helps and a mature church-based checking process. Behind us: nothing checkable by code.

The AI committee editionThe Anselm Project Bible (APB) 4.0, October 2026 — the one complete AI translation from the source we could find

What they do

The closest cousin and in several respects ahead: OSHB + SBLGNT/MorphGNT as the source; 14,877 variation units from open apparatus decided blind by two or three model families; one LLM in nine roles (analysis, draft, segment review, audit, terminology, style, proofread, formal English, blind meaning review); the drafter not told it is Scripture, no book or verse reference; a RECALL GATE (≥ 30 shared words with earlier text fails) and a post-hoc comparison with four published versions against a ref-vs-ref ceiling; per-book consistency passes; eight blind English readers; every verse opens its tokens, reasoning and notes; the text CC BY 4.0. No person edited a verse.

What we do differently

APB proved the blinded drafter and the recall gate work; we adopted both (the gate is live, the acceptance run on John 3 is pending) and the textual ledger is being built on the same open apparatus. Where we go further: APB's consistency is per lemma and its ledger is a published log; ours is per REFERENT with kinship, period and geocoding on the node, and the provenance chain is VERIFIABLE — frozen source commitments → PROV run record → content commitment per verse → a chartered issuer's signature → a Merkle root anyone can check. APB reports its audits; we publish the checker's own precision and recall and refuse a rule change the regression suite prices badly. APB has no human in the loop by design; we keep a blind review queue because a translation without an exegete is a draft, however good. And every term, sense, rule and referent here is an open ontology a second project can import, not a project-internal table.

Who is ahead on what. Ahead of us: a complete Bible; a decided critical text with 14,877 units; multi-family review on every verse; readability testing. Behind us: a verifiable provenance chain; a referent graph with an open T-box; measured checker precision/recall; pre-registered locked evaluation sets; a human review path.

General LLM-translation evaluationInspect AI, Promptfoo, DeepEval; Last Translation Benchmark, RATE; COMET, MetricX, chrF

What they do

The general harnesses run experiments over any model and task with custom scorers, trajectory inspection, log viewers and rescoring; the Last Translation Benchmark attaches explicit verification rules to each hard example; RATE evaluates non-literal language with retrieval and pairwise comparison; the learned metrics score similarity to a reference.

What we do differently

We own the runner (the experiment lives in the agent runtime beside the org's grant and the gateway knobs) and take the PATTERNS: rescoring stored runs, trajectory graders, per-case verification rules (as typed acceptance conditions), evaluator validation against reviewers. The one thing we refuse that the general tooling invites is treating similarity to a published English Bible as quality — chrF against the WEB is a recitation DIAGNOSTIC here, reported per edition and never quoted as a score, because a drafter tuned on it learns to recite the WEB.

Who is ahead on what. Ahead of us: log viewers and a decade of UX. Behind us: nothing domain-specific — they supply the harness; the Scripture tests, the referents and the rules are ours to bring.

The differentiated value, in eight sentences

The unit of consistency is a referent, not a string
Everyone else's terminology tooling — Paratext biblical terms, Greek Room, APB's per-lemma pass — works on words. Ours works on nodes with kinship, period, geocoding and cross-references, so the check knows which Judas, which Zechariah, which Lord, and a second language inherits every decision as rows on the same nodes.
The ontology generates the artefacts instead of describing them
Skill record sections, the rules engine's JSON, the knowledge-base projection the tools read, the code's vocabularies, the policy register, the plan contract — each is a build output with a check that refuses drift. In every other project we looked at, the term list, the style guide and the checker are three documents that agree by diligence.
The checker is measured before the model is
A false-positive floor and ceiling on dev and a catch rate per planted error kind on regression, reported on every rule change. No field project we found publishes its checker's precision and recall; APB publishes audits but not the auditor's own error rate.
Provenance is verifiable, not narrated
Frozen source commitments, a PROV record per run with the model, prompt version, tool outputs and checks, a content commitment per verse, a chartered issuer's signature, a corpus root. APB publishes a ledger; NET publishes notes; neither can be verified by a second party from the artefacts alone.
Recitation is measured and gated, not assumed away
A model that is forbidden English in its prompt still carries English in its weights. We measured it (John 3 against the BSB: 0.56 where two independent editions overlap at 0.33), named it, and gate it against a ref-vs-ref ceiling per passage. Among AI efforts only APB does this; among human projects the question does not arise.
Evaluation is pre-registered and never pooled
Locked held-out sets with versions, graders named on every run, judge tier named on every number, failure causes per run, the checker's suite and the model's suites and the behaviour suite kept apart. The number a scholar is shown says what it is.
Open from top to bottom
Text CC BY, ontology and knowledge base CC BY, the Theographic-derived graph CC BY-SA in its own graph, code Apache-2.0, every dependency pinned in a manifest the build enforces. The one project with a comparable text licence (APB) keeps its machinery project-internal; here the T-box, the referents, the rules and the harness are importable by the next edition in the next language.
The human is in the loop by design, not by default
No verse is approved without a named reviewer's verdict; the referent sheet of a book is signed before its verses are; the review is blind to arm and model. The AI committee edition removed the human on principle; the human projects never had a machine to measure. We are building the one where both are present and both are measured.
And the honest column. Today no verse of rbs has passed a human exegete; the textual basis is declared, not decided unit by unit; the drafter sees morphology but not syntax; there is no corpus-wide consistency pass after a book; the quoted numbers are the checker's, not yet a held-out model measurement with the strong judge. Each is an open item with a path in the programme (the blind review queue, the 1,759-unit textual ledger, Macula trees and gold alignments, the per-book pass, the held-out run in flight). The committees have all of these; the Anselm Project has most. What they do not have is the thing this page is about: an ontology that the skills, the knowledge base, the plan and the harness are all generated from and measured against — which is also why every one of those open items has a place to land.

One ontology. Four things generated from it. Every one of them measured.

Frozen sources, a referent graph, skills generated from shapes, a declared plan, deterministic checks with a floor and a ceiling, a harness keyed to the layers it measures, and a licence per layer — this is how every skill on the substrate is built and assessed. The translation is the example where the thing measured is a sentence of Scripture, which makes the power of the ontology, and its limits today, easy to see.