Nishi Family › Compare › Sovereign Model Lifecycle (Modelwright)

Nishi Compare · capabilities, evidence and delivery

Sovereign Model Lifecycle (Modelwright)

Compare capabilities and delivery evidence. Source discovery, qualification, deployment and accepted outcomes are separate; an open contract names work still to verify.

Nishi vs PyTorch and HuggingFace and llama.cpp and Megatron-LM

Overview

The purpose, declared position and evidence coverage of this domain. Source presence and completed acceptance are different measures.

Where we are. Measured 2026-08-19. The loop is REAL and toy-scale: autodiff, an integer no-float transformer that greedy-matches the float reference, BPE, K-quants, GGUF load of Qwen2.5-0.5B and an OpenAI-shaped serve. The matrix was last scored 2026-07-10 and the nofloat lane has since shipped a MoE forward, Muon and AdamW optimisers, distillation, linear and latent attention, MXFP4 and MXFP8 and a DDP autograd gate -- substrate the rungs below compose rather than re-create. What is still absent is alignment (SFT, DPO, LoRA), a standard eval harness, fused kernels, parallel training, GPU training and a model at real scale.

Where we need to go. Train and align a real model on our own substrate: alignment first (the cheapest path to a usable seat), then a harness that cannot be gamed, then kernels, parallelism and silicon, then a 100M-plus pretrain -- every step bit-exact reproducible, the structural exceed the float field cannot match.

The unit. 1 u = one measured session-leg. Calibration from landed rungs: the mangagen panel compositor went from existing substrate to shipped and live-verified in ONE leg (2026-08-13); the citations rung went from 3 to 55 domains in one leg across seven seats (2026-08-18); a greenfield engine with a bite-proven gate has measured 2 to 4 legs. Estimates recalibrate as rungs land and PR7 actuals write back.

Cost to an aligned seat: 5.5 u. Through M0. SFT, LoRA and DPO on the existing integer LM; quality is measured by held-out rules declared before the runs.

Cost to scale architecture: 16 u. Through M2: the harness, fused attention, MoE training, parallel training and a hub.

Cost to a real model: 26 u. Everything below. Pretraining at scale is the deepest rung in the ledger and depends on every kernel and parallel rung before it.

Shared model and system evaluation: PLANNED 2026-10-01. R3 consumes the same Referee acceptance records as Coding and Racing. Compare model versions and effort settings, agent systems, mechanical Nishi and hybrid execution using paired tasks, held-out outcomes, failure classifications, uncertainty, developer time and total cost. Small models earn task-specific routing only after measured acceptance and qualified escalation; names, size and price do not establish rank.

Latest recorded release

No valid dated release entry is recorded for this domain.

Release entries describe recorded changes; they do not establish that every capability passed evaluation.

10 of 21 capability source symbols found|2 of them authored stronger-claims|11 open|coverage 476/1000|adoption 6 full / 4 partial

Evidence profile — what the gaps on this board actually are

Measured by nx_swcompare_evidence, read back by nx_evprofile_lib. Every figure is a count with its denominator — there is deliberately no score, no grade and no percentage anywhere in this band, because a stored scalar is a field a seat can edit and a counted partition is not.

proven able to fail counts the gates that have a RECORDED RED — nx_gate_bite mutated the gate subject, rebuilt it, watched the gate go red, and that record is inside the shared TTL. never bitten is its complement over the same denominator: those gates ran and were green, and nothing has ever shown them able to detect anything, so their green is a statement about this run and not about the gate. green at 0/0 is a separate and much weaker observation — the gate printed GREEN on a zero denominator, so its own tooth counter says it examined nothing. A gate can be green, non-zero, and still never bitten; that is the common case and it is now visible instead of implied.

partition: grounded + unsupported = 10 vs present 10 · named + unnamed + withheld = 11 vs open 11 · both reconcile

liar-kill conj=GPQN · all four conjuncts held

graded document: BUILDROOT tree, 5831 bytes · gates map: PRIMARY · stamped 3d 10h ago · source ../knowledge/status/evstamp_modelwright.verdict

Gap class	What it is, and the work it names
NONE	No gap class fires on this board: every published claim is grounded, the declared gates ran and were green, no watch contract is unnamed or already landed, and the stamp is inside its TTL. That is a statement about evidence, not about depth, scale or polish.

This band reports the referee counts. The per-axis worklist rows — which axis is unsupported, which watch is ready to flip, which gap is unnamed — are printed by nx_swcompare_evidence modelwright itself and are not carried on the stamp, so this page names the classes and the producer names the rows. That split is stated rather than hidden: a count without a worklist is not actionable, and this band is honest about which half of that it is.

Production map

Follow the dependencies, declared acceptance criteria and recorded priorities. Inspect source binding before treating a rank as executable work.

Ranking source binding: STALE_OR_INVALID_BINDING. Recorded priorities require current acceptance evidence and resource checks before execution.

Recorded ranking withheld

Retained ranking is not bound to the current plan and matrix: STALE_OR_INVALID_BINDING. Historical data remains retained. Refresh the ranking after resolving the input differences. Latest execution outcome is unverified.

Declared roadmap — contract, acceptance, executor, effort

Rung	Closes with	Definition of done (pre-declared)	Executor	Est.
Instruction SFT pipeline (R0)	sft_run	Supervised fine-tuning over the 100 percent integer LM on a banked instruction set; held-out exact-match beats the base model by a PRE-DECLARED margin; the run is bit-exact reproducible on a second CPU (the exceed this lane already holds extends to training)	Organ	2 u
LoRA adapters (R1) after R0	lora_apply	Rank-r adapters on the attention projections trained integer; merge reproduces the full-weight result bit-exact; the existing adapter pool registry (nx_lora_pool) is the store, not a new one	Organ	1.5 u
DPO preference alignment (R2) after R0	dpo_step	DPO loss over banked preference pairs; win-rate against the SFT model on held-out pairs PRE-DECLARED; a run that does not beat SFT stays unwired	Organ	2 u
Standardized eval harness (R3)	eh_run	MMLU and HumanEval-class tasks run from banked datasets with exact-match and pass-at-1; the harness is shared with the referee domain (its std_bench row names the same capability) so one ruler grades every model	Organ	2 u
Flash-attention class fused kernel (R4)	fa_fused	Tiled attention that never materialises the score matrix; bit-identical to nx_attention at every tested length; measured speedup over the plain path at 2k context is published as a number	Organ	2 u
Mixture-of-experts training (R5) after R4	moe_train_step	Router plus experts trained end to end in integer (the nofloat lane already ships the MoE forward and its arch gate); load-balance loss; held-out beats dense at equal active parameters, PRE-DECLARED	Organ	2.5 u
Tensor and data-parallel training (R6) after R4	tp_shard	Sharded GEMM across processes over the mesh transport; bit-exact against the single-process run (the nofloat DDP autograd gate is the precedent); scaling efficiency printed per worker count	Organ	3 u
GPU training step (R7) after R4	gpu_train_step	The integer train step executes on the 5080 through the sovereign GPU lane; step bits equal the CPU step; tokens per second published	Organ	4 u
Speed published vs llama.cpp (R8) after R4,R7	ts_bench	Decode and train tokens per second measured on the same box as llama.cpp with the same model; the ratio is a ratchet floor that refuses regression	Organ	1 u
Model hub (R10)	mh_publish	Content-addressed model cards plus weights served from the estate with sha-verified pull; composes the container registry CAS already proven	Organ	1 u
Pretraining at real scale (R9) after R5,R6,R7	ps_run	A 100M-plus parameter integer model pretrained on the banked corpus to a PRE-DECLARED held-out perplexity; checkpoints content-addressed; the run is resumable and bit-exact	Local model	5 u

Milestones

Milestone	Rungs	Cumulative
M0 · Align what we have	R0,R1,R2	5.5 u
M1 · Kernels and an honest harness	R3,R4	9.5 u
M2 · Scale architecture	R5,R6,R10	16 u
M3 · Silicon	R7,R8	21 u
M4 · A real model	R9	26 u

Ladder verdict. NOT DECLARED. This board names no dated best-in-class or frontier target and no rung roles (sotatarget and rungrole rows on its plan); the ranker labels it NO-LADDER until it does, and until then its rungs climb toward a target nobody has written down. Bars read NO-BAR against the current month 2026-10.

Bar freshness, counted
Class	Count	Note
bars	0	sotabar rows on the plan
fresh	0	the bar month is the current month
attested	0	an older bar with a this-month barscan reporting no newer entry
stale	0	a this-month scan saw a newer month the bar ignores
unattested	0	nobody looked this month
malformed	0	a sotabar row missing a field
duplicate	0	bar ids an earlier row already carries
bars, summed	0	RECONCILED: the parts sum to the total 0
current month	2026-10	the month every bar is judged against

Treatment verdict. NOT DECLARED. No rung on this board declares its three-step treatment (a treat row naming the MCP row, the API route, the primitive it composes, the workflow that composes it and the agent beat that runs it); the ranker labels every rung TREATMENT-UNDECLARED until it does.

Inspect a rung and its prerequisites

Declared nodes 11. Rank input binding: STALE_OR_INVALID_BINDING. Dependency order is authored. Implementation, acceptance evidence, authority and resource readiness are unverified. No action is recommended or dispatched here.

Plan SHA-256 501b6f2fd1c3dc6d5d358d1d4a52e3d24176e285f07632e055a4de50b6dd0251. Target rows 0; role rows 0. Existing risks and release worklog retain their own scope; no node completion is inferred.

Runtime observation coverage: 0 of 11 rungs have current, identity-bound execution observations. Observation may report RED. Accepted completion remains unknown; source presence, qualification and deployment do not establish it.

Use Enter or Space on a rung to inspect its contract. Prerequisite links locate another rung in this list; open its summary to inspect it. Estimates are authored effort, not forecasts.

R0 — Instruction SFT pipeline
Prerequisites: None declared; this does not establish execution eligibility.
Contract: sft_run
Acceptance: Supervised fine-tuning over the 100 percent integer LM on a banked instruction set; held-out exact-match beats the base model by a PRE-DECLARED margin; the run is bit-exact reproducible on a second CPU (the exceed this lane already holds extends to training)
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R1 — LoRA adapters
Prerequisites: R0 (acceptance unverified)
Contract: lora_apply
Acceptance: Rank-r adapters on the attention projections trained integer; merge reproduces the full-weight result bit-exact; the existing adapter pool registry (nx_lora_pool) is the store, not a new one
Authored effort: 1.5. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R2 — DPO preference alignment
Prerequisites: R0 (acceptance unverified)
Contract: dpo_step
Acceptance: DPO loss over banked preference pairs; win-rate against the SFT model on held-out pairs PRE-DECLARED; a run that does not beat SFT stays unwired
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R3 — Standardized eval harness
Prerequisites: None declared; this does not establish execution eligibility.
Contract: eh_run
Acceptance: MMLU and HumanEval-class tasks run from banked datasets with exact-match and pass-at-1; the harness is shared with the referee domain (its std_bench row names the same capability) so one ruler grades every model
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R4 — Flash-attention class fused kernel
Prerequisites: None declared; this does not establish execution eligibility.
Contract: fa_fused
Acceptance: Tiled attention that never materialises the score matrix; bit-identical to nx_attention at every tested length; measured speedup over the plain path at 2k context is published as a number
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R5 — Mixture-of-experts training
Prerequisites: R4 (acceptance unverified)
Contract: moe_train_step
Acceptance: Router plus experts trained end to end in integer (the nofloat lane already ships the MoE forward and its arch gate); load-balance loss; held-out beats dense at equal active parameters, PRE-DECLARED
Authored effort: 2.5. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R6 — Tensor and data-parallel training
Prerequisites: R4 (acceptance unverified)
Contract: tp_shard
Acceptance: Sharded GEMM across processes over the mesh transport; bit-exact against the single-process run (the nofloat DDP autograd gate is the precedent); scaling efficiency printed per worker count
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R7 — GPU training step
Prerequisites: R4 (acceptance unverified)
Contract: gpu_train_step
Acceptance: The integer train step executes on the 5080 through the sovereign GPU lane; step bits equal the CPU step; tokens per second published
Authored effort: 4. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R8 — Speed published vs llama.cpp
Prerequisites: R4 (acceptance unverified), R7 (acceptance unverified)
Contract: ts_bench
Acceptance: Decode and train tokens per second measured on the same box as llama.cpp with the same model; the ratio is a ratchet floor that refuses regression
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R10 — Model hub
Prerequisites: None declared; this does not establish execution eligibility.
Contract: mh_publish
Acceptance: Content-addressed model cards plus weights served from the estate with sha-verified pull; composes the container registry CAS already proven
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
R9 — Pretraining at real scale
Prerequisites: R5 (acceptance unverified), R6 (acceptance unverified), R7 (acceptance unverified)
Contract: ps_run
Acceptance: A 100M-plus parameter integer model pretrained on the banked corpus to a PRE-DECLARED held-out perplexity; checkpoints content-addressed; the run is resumable and bit-exact
Authored effort: 5. Executor kind: Local model. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.

Learning and practice paths

No structured learning path is declared for this plan. Existing research, roadmap and worklog remain available above.

Rung dossiers — every record that bears on a rung, in one place

Joined by symbol, never typed. Each dossier is assembled on every publish from the rows this board already carries: the plan's rung row, the matrix row that carries its contract symbol (its status re-measured by the one symbol ruler), the gate the organ declares and the verdict the evidence referee recorded on its last run, the reference marks in the rung text, the design rows that name the rung and the work log filed against it. The capability matrix links each cell to its dossier and each dossier links back to its cell and forward to the rungs it stands on; a dependency naming no rung on this plan is written as UNRESOLVED rather than linked. Absences are named: NO-MATRIX-ROW, NO-GATE-DECLARED, UNRECORDED.

Gate verdicts: UNSTAMPED — no per-gate verdict artifact is published for this domain yet (nx_swcompare_evidence modelwright writes it beside its stamp); every gate below reads UNRECORDED until it runs.

Gate declarations: knowledge/organ_gate.conf read from this working directory (1 rows) and from the estate root (196 rows); rows in both counted once: 0; declarations read: 197. Every declaration in either copy counts, so a stub beside the publisher can never hide the root.

R0 Instruction SFT pipeline · cell WATCHING · gate NO-GATE-DECLARED

Contract	`sft_run` · executor Organ · 2 u · stands on nothing
Definition of done	Supervised fine-tuning over the 100 percent integer LM on a banked instruction set; held-out exact-match beats the base model by a PRE-DECLARED margin; the run is bit-exact reproducible on a second CPU (the exceed this lane already holds extends to training)
Matrix cell	Instruction fine-tuning (SFT) pipeline · `runtime/nx_sft.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_sft`; declare `nx_sft TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R1 LoRA adapters · cell WATCHING · gate NO-GATE-DECLARED

Contract	`lora_apply` · executor Organ · 1.5 u · stands on R0
Definition of done	Rank-r adapters on the attention projections trained integer; merge reproduces the full-weight result bit-exact; the existing adapter pool registry (nx_lora_pool) is the store, not a new one
Matrix cell	LoRA / parameter-efficient fine-tuning · `runtime/nx_lora.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_lora`; declare `nx_lora TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R2 DPO preference alignment · cell WATCHING · gate NO-GATE-DECLARED

Contract	`dpo_step` · executor Organ · 2 u · stands on R0
Definition of done	DPO loss over banked preference pairs; win-rate against the SFT model on held-out pairs PRE-DECLARED; a run that does not beat SFT stays unwired
Matrix cell	RLHF / DPO preference alignment · `runtime/nx_dpo.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_dpo`; declare `nx_dpo TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R3 Standardized eval harness · cell WATCHING · gate NO-GATE-DECLARED

Contract	`eh_run` · executor Organ · 2 u · stands on nothing
Definition of done	MMLU and HumanEval-class tasks run from banked datasets with exact-match and pass-at-1; the harness is shared with the referee domain (its std_bench row names the same capability) so one ruler grades every model
Matrix cell	Standardized eval harness (MMLU / HumanEval) · `runtime/nx_eval_harness.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_eval_harness`; declare `nx_eval_harness TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R4 Flash-attention class fused kernel · cell WATCHING · gate NO-GATE-DECLARED

Contract	`fa_fused` · executor Organ · 2 u · stands on nothing
Definition of done	Tiled attention that never materialises the score matrix; bit-identical to nx_attention at every tested length; measured speedup over the plain path at 2k context is published as a number
Matrix cell	Flash-attention / fused training kernels · `runtime/nx_flash_attn.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_flash_attn`; declare `nx_flash_attn TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R5 Mixture-of-experts training · cell WATCHING · gate NO-GATE-DECLARED

Contract	`moe_train_step` · executor Organ · 2.5 u · stands on R4
Definition of done	Router plus experts trained end to end in integer (the nofloat lane already ships the MoE forward and its arch gate); load-balance loss; held-out beats dense at equal active parameters, PRE-DECLARED
Matrix cell	Mixture-of-experts training · `runtime/nx_moe_train.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_moe_train`; declare `nx_moe_train TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R6 Tensor and data-parallel training · cell WATCHING · gate NO-GATE-DECLARED

Contract	`tp_shard` · executor Organ · 3 u · stands on R4
Definition of done	Sharded GEMM across processes over the mesh transport; bit-exact against the single-process run (the nofloat DDP autograd gate is the precedent); scaling efficiency printed per worker count
Matrix cell	Distributed tensor-parallel training · `runtime/nx_tensor_parallel.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_tensor_parallel`; declare `nx_tensor_parallel TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R7 GPU training step · cell WATCHING · gate NO-GATE-DECLARED

Contract	`gpu_train_step` · executor Organ · 4 u · stands on R4
Definition of done	The integer train step executes on the 5080 through the sovereign GPU lane; step bits equal the CPU step; tokens per second published
Matrix cell	GPU / CUDA training · `runtime/nx_gpu_train.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_gpu_train`; declare `nx_gpu_train TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R8 Speed published vs llama.cpp · cell WATCHING · gate NO-GATE-DECLARED

Contract	`ts_bench` · executor Organ · 1 u · stands on R4, R7
Definition of done	Decode and train tokens per second measured on the same box as llama.cpp with the same model; the ratio is a ratchet floor that refuses regression
Matrix cell	Competitive train and inference speed · `runtime/nx_train_speed.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_train_speed`; declare `nx_train_speed TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R10 Model hub · cell WATCHING · gate NO-GATE-DECLARED

Contract	`mh_publish` · executor Organ · 1 u · stands on nothing
Definition of done	Content-addressed model cards plus weights served from the estate with sha-verified pull; composes the container registry CAS already proven
Matrix cell	Model hub and distribution · `runtime/nx_model_hub.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_model_hub`; declare `nx_model_hub TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

R9 Pretraining at real scale · cell WATCHING · gate NO-GATE-DECLARED

Contract	`ps_run` · executor Local model · 5 u · stands on R5, R6, R7
Definition of done	A 100M-plus parameter integer model pretrained on the banked corpus to a PRE-DECLARED held-out perplexity; checkpoints content-addressed; the run is resumable and bit-exact
Matrix cell	Large-scale pretraining (billions of params, trillions of tokens) · `runtime/nx_pretrain_scale.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_pretrain_scale`; declare `nx_pretrain_scale TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

dossiers=11 cells_joined=11 no_matrix_row=0 (sum 11) gates_recorded=0 gates_unrecorded=0 no_gate_declared=11 (sum 11 of cells_joined) evgates=UNSTAMPED

Capability comparisons

Compare the field, search individual capabilities and open their source and adoption evidence. Documented presence does not establish comparative quality.

Position map — centrality and distinctiveness

The four-quadrant map the field uses for brand strategy (Dawar and Bagga, HBR June 2015), re-derived from this matrix on every publish. Centrality is the share of the category's feature mass a player covers, each feature weighted by how many hold it; distinctiveness is the average lead over each rival on the rows the player holds; breadth is the depth-weighted share of the whole matrix (the bubble); depth is how deeply the rows held are held; momentum is the day-over-day move off the spine (green rising, red falling, grey until day two); the dashed path runs first day → previous day → today. Dividers are the category means. Axes are fitted to the field of play, so read the tick numerals, not the frame. Rival marks are documented presence, so a rival's position reads the record, never its quality. The picture grades its own readability below; the table beside it is the same data for a screen reader or a second method.

Rows. 21 feature rows mapped of 21 matrix rows; 0 substrate rows (kernels, bounds and instruments the plan's rungrole marks substrate) are the estate's scaffolding, not category features, and stay off the map

Views. 2D cut: centrality, distinctiveness · 3D cube: centrality, distinctiveness, breadth · axes registered: centrality, distinctiveness, breadth, depth, momentum · a board picks its own in knowledge/compare/modelwright.cdmap (cut|x|y, cube|x|y|z); absent = the HBR defaults

bubble area = breadth · ring = momentum (green rising, red falling, grey until day two) · dashed = category means · axes fitted to the field of play: centrality 400–1000, distinctiveness 175–325 of 0–1000 permil (the full range put every player in one corner)
readability of the 2D cut, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 0 (a fact of the data: two players that close are that close) · data spread 743 permil of the plot · quadrant words unseated 0
text contrast, measured with wcag2-ratio (floors from contrast.conf), light theme: labels 16.24 (floor 4.50) · notes 16.24 (floor 4.50) · quadrant words 5.89 (floor 4.50) · tick numerals 5.89 (floor 4.50) · axis titles 5.59 (floor 4.50) · dark theme: labels 13.78 (floor 4.50) · quadrant words 5.55 (floor 4.50) · axis titles 5.97 (floor 4.50) · dark classes under their floor 0 (one figure serves both themes: a dark shortfall is a token to fix, never a class to hide) · classes refused under their floor 0 (a refused class is not drawn; the scale classes are measured, never hidden) · export: SVG PNG (receipt, rendered by the estate's own rasteriser from this page)

axes fitted: centrality 400–1000 · distinctiveness 175–325 · breadth 300–800 permil · farther bubbles are painted first, nearer ones over them · the floor shadow is each bubble's (x, y) at height 0
readability of the 3D cube, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 1 · unresolved labels 0 · mark overlaps 0 (a fact of the data: two players that close are that close) · data spread 322 permil of the plot

Nishi PyTorch HuggingFace llama.cpp Megatron-LM
10 panels over 5 registered axes, every pair once (the lower axis on x, the higher on y) · each panel fitted to its own field of play, first and last tick numerals shown · no labels in a small cut, the legend names the colours; the grade below reports the mark terms only (MM summed over the panels, spread averaged)
readability of the small multiples, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 2 (a fact of the data: two players that close are that close) · data spread 565 permil of the plot

Player	Quadrant	centrality	distinctiveness	breadth	depth	momentum	Rows held	Days on spine	First seen
Nishi	Unconventional	506	250	349	733	0 since 2026-09-23	10	10	2026-09-15
PyTorch	Aspirational	974	302	714	789	0 since 2026-09-23	19	10	2026-09-15
HuggingFace	Mainstream	909	196	555	686	0 since 2026-09-23	17	10	2026-09-15
llama.cpp	Mainstream	818	233	555	777	0 since 2026-09-23	15	10	2026-09-15
Megatron-LM	Mainstream	831	213	507	666	0 since 2026-09-23	16	10	2026-09-15

Day	Matrix rows reviewed	Players recorded
2026-09-15	21	5
2026-09-16	21	5
2026-09-17	21	5
2026-09-18	21	5
2026-09-19	21	5
2026-09-20	21	5
2026-09-21	21	5
2026-09-22	21	5
2026-09-23	21	5
2026-10-08	21	5

How to read this evidence. A Nishi source mark records whether the named symbol is declared in the selected source file. It does not establish working behavior or accepted delivery. A watching tag names an expected source entry; discovering it updates source coverage only. A dark tag means the file exists but the named symbol was not found: inspect the source and contract before assuming the capability is missing or renaming code. Peer codes are authored assessments; unassessed means no comparison is established, not absence. Qualification, deployment identity, runtime observations and acceptance must carry their own evidence. Adoption records the catalog's observed path through source, build, promotion, registration and invocation; libraries use importer evidence and gates use declared execution surfaces. A full catalog path does not establish quality, freshness or a successful user outcome. Partial and unknown states retain their stated next action. Census stamps: importers asof 1790637268, gate census asof 1790104131 (unix seconds; -1 = census absent).

Capability matrix — measured against source

◉ authored stronger claim; source present● present◐ partial○ absent? unassessed; excluded from relative comparison · click any capability for its evidence

Peer cell coverage: authored assessed 84, unassessed 0. Authored assessments are not verified outcomes.

Capability	Nishi	PyTorch	HuggingFace	llama.cpp	Megatron-LM
Reverse-mode autodiff training substrate Measured: `ta_new` exists in `runtime/nx_autograd_tensor.nx`, verified at emit. Tensor reverse-mode autograd; the first sovereign LM trained from scratch beat the analytic midpoint bit-exact (role scorecard MODELWRIGHT, 2026-06-10); PyTorch autograd is the bar [pytorch-autograd] Adoption: `SOURCE-ONLY` — PARTIAL: source exists, never compiled: /api/build it. not adopted: source exists, never compiled: /api/build it Pros Implementing source symbol found; runtime acceptance separate; ahead of llama.cppCons behind PyTorch (leads); not adopted yet: source exists, never compiled: /api/build it	●	◉	●	○	●
Transformer forward (100 percent integer no-float) Measured: `qmul` exists in `runtime/nx_nofloat_llm.nx`, verified at emit. The core forward every model has, done with zero floating point rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=34 nonval=8` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
BPE tokenizer training Measured: `nx_bpe_vocab_new` exists in `runtime/nx_bpe.nx`, verified at emit. Own byte-pair tokenizer + vocab training rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `SOURCE-ONLY` — PARTIAL: source exists, never compiled: /api/build it. not adopted: source exists, never compiled: /api/build it Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: source exists, never compiled: /api/build it	●	●	●	●	●
Integer K-quant weights Measured: `nx_q4k_dot_row_col` exists in `runtime/nx_q4k_matmul.nx`, verified at emit. Q4-K dot kernels; llama.cpp K-quants are the CPU bar [llamacpp]; TRT/Megatron are GPU-float Adoption: `LIB-WIRED importers=15 nonval=9` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of Megatron-LM; fully adopted on the estate ladderCons behind llama.cpp (leads)	●	●	●	◉	○
SIMD integer GEMM Measured: `i32x8_hsum` exists in `runtime/nx_nofloat_gemm.nx`, verified at emit. AVX2 integer GEMM (7x pooled); the field's GEMM is float/cuBLAS rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=3` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons behind PyTorch (leads), llama.cpp (leads); not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	◉	●	◉	●
Open-weights GGUF loading Measured: `nx_gguf_load_model_weights` exists in `runtime/nx_gguf_load_model.nx`, verified at emit. Real Qwen2.5-0.5B loads and greedy-matches the float reference 4-for-4 (2026-07-09); llama.cpp is the GGUF home rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=2 nonval=1` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons behind PyTorch (leads), HuggingFace (leads), llama.cpp (leads)	●	◉	◉	◉	●
Served chat API (OpenAI-shaped) Measured: `ls_extract_prompt` exists in `runtime/nx_f32_llm_serve.nx`, verified at emit. Sovereign seat on :11434 serving real Qwen; vLLM/llama.cpp lead production serving rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `RUN-BY:daemon` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of Megatron-LM; fully adopted on the estate ladderCons behind HuggingFace (leads), llama.cpp (leads)	●	●	◉	◉	○
Attention and layernorm forward Measured: `nx_attn_score_matrix` exists in `runtime/nx_attention.nx`, verified at emit. Score-matrix attention + softmax; the transformer core rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=8 nonval=5` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Large-scale pretraining (billions of params, trillions of tokens) Open — watching `runtime/nx_pretrain_scale.nx` : `ps_run`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. Megatron/PyTorch FSDP pretrain frontier models; ours is a toy LM rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching ps_run Pros none measured yetCons behind PyTorch (leads), HuggingFace, llama.cpp, Megatron-LM; open contract; expected source declaration not established	○	◉	●	●	◐
GPU / CUDA training Open — watching `runtime/nx_gpu_train.nx` : `gpu_train_step`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. CUDA/ROCm training is the bar; Nishi trains CPU-integer by design today rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching gpu_train_step Pros none measured yetCons behind PyTorch (leads), llama.cpp, Megatron-LM; open contract; expected source declaration not established	○	◉	○	●	◐
Distributed tensor-parallel training Open — watching `runtime/nx_tensor_parallel.nx` : `tp_shard`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. Megatron-LM 3D parallelism is the bar [megatron-lm]; Nishi single-process dossierwatching tp_shard Pros none measured yetCons behind PyTorch, Megatron-LM (leads); open contract; expected source declaration not established	○	●	○	○	◉
Instruction fine-tuning (SFT) pipeline Open — watching `runtime/nx_sft.nx` : `sft_run`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. HuggingFace TRL SFTTrainer is the bar [trl]; no SFT loop here dossierwatching sft_run Pros none measured yetCons behind PyTorch, HuggingFace, Megatron-LM; open contract; expected source declaration not established	○	●	◐	○	●
RLHF / DPO preference alignment Open — watching `runtime/nx_dpo.nx` : `dpo_step`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. TRL DPO/PPO alignment is the bar [trl] [dpo2023]; the models run un-aligned dossierwatching dpo_step Pros none measured yetCons behind PyTorch, HuggingFace, Megatron-LM; open contract; expected source declaration not established	○	●	◐	○	●
LoRA / parameter-efficient fine-tuning Open — watching `runtime/nx_lora.nx` : `lora_apply`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. PEFT/LoRA adapters are the bar [lora2021]; absent here dossierwatching lora_apply Pros none measured yetCons behind PyTorch, HuggingFace, llama.cpp, Megatron-LM; open contract; expected source declaration not established	○	●	◐	●	●
Standardized eval harness (MMLU / HumanEval) Open — watching `runtime/nx_eval_harness.nx` : `eh_run`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. lm-eval-harness is the field standard [lm-eval-harness]; ours is qabench (referee census) not a model-eval harness dossierwatching eh_run Pros none measured yetCons behind PyTorch, HuggingFace (leads), llama.cpp, Megatron-LM; open contract; expected source declaration not established	○	●	◉	●	●
Flash-attention / fused training kernels Open — watching `runtime/nx_flash_attn.nx` : `fa_fused`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. FlashAttention fused kernels are the bar [flashattn2022]; ours is a plain score matrix dossierwatching fa_fused Pros none measured yetCons behind PyTorch (leads), HuggingFace, llama.cpp, Megatron-LM; open contract; expected source declaration not established	○	◉	●	●	◐
Mixture-of-experts training Open — watching `runtime/nx_moe_train.nx` : `moe_train_step`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. Sparse MoE training (Megatron/DeepSpeed); Nishi dense-only rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching moe_train_step Pros none measured yetCons behind PyTorch, HuggingFace, llama.cpp, Megatron-LM (leads); open contract; expected source declaration not established	○	●	●	●	◉
Competitive train and inference speed Open — watching `runtime/nx_train_speed.nx` : `ts_bench`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. Measured 2.4 tok/s CPU decode = 8-25x behind llama.cpp-class; GPU stacks train orders faster rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching ts_bench Pros none measured yetCons behind PyTorch (leads), HuggingFace, llama.cpp (leads), Megatron-LM (leads); open contract; expected source declaration not established	○	◉	●	◉	◉
Model hub and distribution Open — watching `runtime/nx_model_hub.nx` : `mh_publish`, re-measured on every compare beat. Ship that symbol and this mark flips itself; the `comparewatch-` plane row flips with it. HuggingFace Hub is the bar [hf-transformers]; our models live on the NAS, not a public hub dossierwatching mh_publish Pros none measured yetCons behind PyTorch, HuggingFace (leads), llama.cpp; open contract; expected source declaration not established	○	●	◉	●	○
100 percent integer no-float train and inference (bit-exact reproducible by construction) Source present; authored stronger claim: `qmul` in `runtime/nx_nofloat_llm.nx`, verified at emit. A 100 percent integer LLM greedy-matches the float reference 4-for-4 and reproduces bit-identically on any CPU; the entire field is float and nondeterministic across runs/hardware Adoption: `LIB-WIRED importers=34 nonval=8` — fully adopted (top of its ladder). Pros Source symbol found; stronger capability claim is authored; ahead of PyTorch, HuggingFace, llama.cpp, Megatron-LM; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	◉	○	○	○	○
Sovereign whole training-and-serving loop (own language, compiler, kernels; zero PyTorch/CUDA/BLAS) Source present; authored stronger claim: `ta_new` in `runtime/nx_autograd_tensor.nx`, verified at emit. Train + quantize + serve entirely on our own stack bits-up; PyTorch/Megatron sit on CUDA + cuBLAS, llama.cpp on foreign C++ toolchain -- our brain runs on OUR substrate, the literal own-the-loop Adoption: `SOURCE-ONLY` — PARTIAL: source exists, never compiled: /api/build it. not adopted: source exists, never compiled: /api/build it Pros Source symbol found; stronger capability claim is authored; ahead of PyTorch, HuggingFace, llama.cpp, Megatron-LMCons not adopted yet: source exists, never compiled: /api/build it	◉	○	○	○	○

Rival-claim provenance. Every Yes, Best or Part mark in a rival column is a claim about someone else's product. A cited row carries a reference mark that resolves to a pinned mirror (the refs gate measures that); an uncited row is an observation read and is badged in its evidence until a reference lands. The badge is the receipt, never the proof: a mark proves a mirror exists, not that the mirror supports the code. The rows are counted below.

Rival claims, counted
Class	Count	Note
rows with rival marks	19	rows carrying a Yes, Best or Part in a rival column
cited	9	a reference mark resolves to a pinned mirror
uncited	10	an observation read, badged until a reference lands
rows, summed	19	RECONCILED: the parts sum to the total 19

Delivery and evidence

Inspect risks, technical debt, rendered observations, experiments and references. Read scope and limitations alongside every result.

On these two registers. Rows are declared in the domain's plan file and carry the debt id, which is the join key back to the sovereign debt plane — that plane, not this page, is the authority on state. Reconciling them automatically (the regen reading the plane and refreshing these rows) is a named, owed rung; until it lands, treat an id here as a pointer to look up, not a status to trust.

Honest verdict. The Modelwright owns Nishi's own brain -- and the honest headline is that it is REAL but TOY-scale. It trains from scratch (a reverse-mode autodiff substrate; the first sovereign LM beat the analytic midpoint bit-exact, 2026-06-10), it runs a 100 percent integer no-float transformer that greedy-matches the float reference 4-for-4 (2026-07-09), it loads real open weights (Qwen2.5-0.5B via GGUF), tokenizes with its own BPE, quantizes to integer K-quants, and serves an OpenAI-shaped chat API -- the whole loop is ours, our brain not Claude's. But at production scale it is not close: no large-scale pretraining, no GPU or CUDA training, no distributed tensor-parallelism (Megatron), no instruction fine-tuning or RLHF/DPO alignment (TRL), no LoRA, no standardized eval harness, and measured CPU decode is 8-25x behind llama.cpp-class. The two genuine exceeds are structural, not scale: 100 percent integer training and inference is bit-exact reproducible BY CONSTRUCTION where the entire field is float and nondeterministic, and the whole stack is ours bits-up -- own language, compiler, kernels, zero PyTorch/CUDA/BLAS beneath. The climb is the deepest rung in the ledger: train a real model at real scale on our own substrate, then alignment and an eval harness (which the referee shares).

Person · product · place — not yet measured for this domain

Every compare carries this layer. Declare knowledge/compare/modelwright.ppp (rows surface|nishi or c1..c4|label|url|connect naming OUR live surface and each rival's front door), run nx_ppp_probe domain modelwright, and this section fills itself on the next beat: the same ruler on both sides — privacy and CX (third-party hosts, tracker classes, cookies, security headers), design and longevity (design hygiene, computed WCAG contrast, render-blocking resources, unsized media, script weight, theme and motion queries), findability (landmarks, skip link, on-site search, breadcrumb, headings, internal links).

The field — discovered, not chosen

Rows written by nx_field_discover from modelwright.seeds: the industry's own lists (Wikipedia wikitext, GitHub topics, awesome lists) read mechanically, every candidate counted across seeds. The matrix columns above are a SEAT'S pick; this band is the population they were picked from, and the stats line measures one against the other. A rival here is a lead, never a verdict — it earns a column when its capabilities are read and pinned.

Discovery receipt. One row per counter the run wrote, in the receipt's own order; the rival rows follow in their own table.

Field discovery, counted
Class	Count	Note
seeds	4
scanned	4
fetched	4
reused	0
failed	0
named	4
candidates	4
mentions	4
capped	0

Rank	Rival	Seeds	Mentions	First seed	Kind	Link
1	PyTorch	1	1	col0-pytorch	named	https://pytorch.org/docs/2.13/autograd.html
2	HuggingFace	1	1	col1-huggingface	named	https://huggingface.co/docs/transformers/index
3	llama.cpp	1	1	col2-llama	named	https://github.com/ggml-org/llama.cpp
4	Megatron-LM	1	1	col3-megatron	named	https://github.com/NVIDIA/Megatron-LM

Exclusive and shared capabilities

One capability is graded on one board; every other board references it. The fleet duplicate census (nx_rivalcensus dupes, on the fleetdupes clock row) reads every board's matrix and names each capability graded as a row on two or more boards, with a home derived from evidence: rung when exactly one board's plan contracts the symbol (that board is starred), gates when no plan contracts it and exactly one board's executed gate map runs the organ's gate (that board is plussed), ambiguous when several boards carry the deciding evidence (a decision for their seats), and none when no evidence decides it, with the reason beside it: unmapped (no board of the duplicate declares a gates map; declare the maps) or unproven (a map exists and runs none of the organ's gates; gate the organ on its proving board, or declare it a shared library by policy). A home elsewhere means this board should carry an @xrow reference to the home board's row rather than a graded row of its own; a home here means the other boards should. The table is this board's slice of one estate-wide census: the shape is shared, the rows are the board's.

This board grades 19 capabilities: 10 exclusive to it and 9 shared with other boards. Shared rows on this page: 9 = home here 0 + home elsewhere 4 + ambiguous 1 + undecided 4 + refused 0 (partition 9); undecided = unmapped 0 + unproven 4 + unevidenced 0; homonyms 0; since the previous census: new 0, resolved 0. Census FRESH age_s=6518.

Capability	Organ	Boards grading it	Home	Rule	Evidence	Standing on this board
qmul	`nx_nofloat_llm.nx`	llm*, lang, modelwright	llm	rung	plan	home elsewhere adopt: `@xrow llm\|qmul\|home by rung (fleet duplicate census)`
nx_attn_score_matrix	`nx_attention.nx`	llm, modelwright	—	none	unproven	undecided
nx_bpe_vocab_new	`nx_bpe.nx`	llm, modelwright	—	none	unproven	undecided
nx_gguf_load_model_weights	`nx_gguf_load_model.nx`	llm, modelwright	—	none	unproven	undecided
nx_q4k_dot_row_col	`nx_q4k_matmul.nx`	llm*, modelwright	llm	rung	plan	home elsewhere adopt: `@xrow llm\|nx_q4k_dot_row_col\|home by rung (fleet duplicate census)`
i32x8_hsum	`nx_nofloat_gemm.nx`	llm*, modelwright	llm	rung	plan	home elsewhere adopt: `@xrow llm\|i32x8_hsum\|home by rung (fleet duplicate census)`
ls_extract_prompt	`nx_f32_llm_serve.nx`	llm*, modelwright	llm	rung	plan	home elsewhere adopt: `@xrow llm\|ls_extract_prompt\|home by rung (fleet duplicate census)`
ta_new	`nx_autograd_tensor.nx`	llm, modelwright	—	none	unproven	undecided
sft_run	`nx_sft.nx`	modelwright, engineshift	—	ambiguous	plan	ambiguous

Gaps from the record — what the estate does that no board carries

The record census (nx_goalmap record) reads the invoked-tool population and every plan queue row and files each organ or directive that NO matrix, plan or gates row names. A row here is a callout the boards missed: adjudicate it onto a board or declare it infrastructure. Census state STALE (age 1395623 s), sources read 4 of 7 declared — a BLIND census is a FLOOR: unread sources can only add rows.

kind	name	board	source	evidence

rows shown 0|this board's directives 0|estate-wide un-boarded organs 452 (listed in full on /compare/ecosystem)|census rows 639|malformed 0 (counted, never rendered)

References

Beyond a link list. Every reference below resolves twice — the publisher's copy and, where banked, the estate's own non-rottable library mirror with a content pin — and carries its evidence class plus the exact claim on this page it grounds. Keyed marks like [key] in the matrix notes jump here. A dash means honestly absent, never assumed.

[pytorch-autograd] PyTorch. Automatic differentiation package -- torch.autograd. PyTorch 2.13 documentation. Accessed August 2026. publisher · read in our library knowledge/fetched/cmp_modelwright_pytorch-autograd.html · pin h6a11d941924bc30f6b0bda0181b07a7df63c84650e9bd97e7efd0b8408c14c6f · accessed 2026-08-18 · vendor-docGrounds: The PyTorch column and the BARS line (PyTorch v2.13.0): the Reverse-mode autodiff training substrate row (PyTorch autograd is the bar nx_autograd_tensor is graded against) and the GPU / CUDA training and Large-scale pretraining cells where PyTorch reads Best.
[hf-transformers] Hugging Face. Transformers documentation (state-of-the-art pretrained models for inference and training; the Hub-backed model library). Accessed August 2026. publisher · read in our library knowledge/fetched/cmp_modelwright_hf-transformers.html · pin h6047febd65c25a6bd5744107f0f82c0b62517dd6e709469431bdb7f1d431b8d5 · accessed 2026-08-18 · vendor-docGrounds: The HuggingFace column and the BARS line (Transformers v5.13.0): Model hub and distribution Best (HuggingFace Hub is the bar; our models live on the NAS), Open-weights GGUF loading and Served chat API cells, and the Standardized eval harness column code.
[trl] Hugging Face. TRL -- Transformer Reinforcement Learning: SFTTrainer, DPOTrainer, PPO/GRPO and reward-model training documentation. Accessed August 2026. publisher · read in our library knowledge/fetched/cmp_modelwright_trl.html · pin hdd3f645f67ca35d24e6f7dd736e2000cb9377df1a052a59c362553e494e519c8 · accessed 2026-08-18 · vendor-docGrounds: The BARS line (TRL v1.8.0) and two absent rows: Instruction fine-tuning (SFT) pipeline (HuggingFace TRL SFTTrainer is the bar; no SFT loop here) and RLHF / DPO preference alignment (TRL DPO/PPO alignment is the bar; the models run un-aligned).
[llamacpp] ggml-org. llama.cpp: LLM inference in C/C++ (project README, GitHub). Accessed August 2026. publisher · read in our library knowledge/fetched/cmp_llm_llamacpp.html · pin h8f4ccd064eee25e9c5294a49af67e94126cf3c7c21070677fc7c0eb55eb8a1a0 · accessed 2026-08-18 · vendor-docGrounds: The llama.cpp column and BARS line: Integer K-quant weights Best (llama.cpp K-quants are the CPU bar), Open-weights GGUF loading (llama.cpp is the GGUF home), SIMD integer GEMM Best, and the Competitive train and inference speed row (measured CPU decode 8-25x behind llama.cpp-class).
[megatron-lm] NVIDIA. Megatron-LM and Megatron Core: GPU-optimized library for training transformer models at scale -- tensor, pipeline, sequence, context and expert parallelism (project README, GitHub). Accessed August 2026. publisher · read in our library knowledge/fetched/cmp_modelwright_megatron.html · pin h20fd935ac0734062eec78ab73cfcfbcb93946803031f531a893f73e68aa4a163 · accessed 2026-08-18 · vendor-docGrounds: The Megatron-LM column and BARS line: Distributed tensor-parallel training (Megatron-LM 3D parallelism is the bar; Nishi single-process), Large-scale pretraining (Megatron/PyTorch FSDP pretrain frontier models) and Mixture-of-experts training (sparse MoE training, Megatron/DeepSpeed).
[lora2021] Hu, Shen, Wallis, Allen-Zhu, Li, Wang, Wang, Chen. LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022. arXiv:2106.09685. publisher · read in our library knowledge/fetched/cmp_modelwright_lora2021.html · pin h70bb70b4fd6d41b8a0f53fc5148017bf6ef5b73acba822027397f861aee135c6 · accessed 2026-08-18 · published-paperGrounds: The LoRA / parameter-efficient fine-tuning row (PEFT/LoRA adapters are the bar; absent here) and the verdict line naming no LoRA as a scale gap: this paper defines the low-rank adapter the nx_lora contract would implement.
[dpo2023] Rafailov, Sharma, Mitchell, Ermon, Manning, Finn. Direct Preference Optimization: Your Language Model is Secretly a Reward Model. NeurIPS 2023. arXiv:2305.18290. publisher · read in our library knowledge/fetched/cmp_modelwright_dpo2023.html · pin hc213a47bb5c67ad1983741bec43fc5e6ab252ae9737bd3e6c8daa2edbf5a3fe3 · accessed 2026-08-18 · published-paperGrounds: The RLHF / DPO preference alignment row: DPO is the reward-model-free preference objective TRL ships as DPOTrainer, i.e. the alignment bar the nx_dpo contract is named after; the models run un-aligned today.
[flashattn2022] Dao, Fu, Ermon, Rudra, Re. FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022. arXiv:2205.14135. publisher · read in our library knowledge/fetched/cmp_modelwright_flashattn2022.html · pin h070112e924e64cb514df26ecf174263f5d3343560438a88086d4a7c478547f64 · accessed 2026-08-18 · published-paperGrounds: The Flash-attention / fused training kernels row (FlashAttention fused kernels are the bar; ours is a plain score matrix) and the Attention and layernorm forward row it is measured beside -- IO-aware tiling is what nx_attention lacks.
[lm-eval-harness] EleutherAI. Language Model Evaluation Harness: a unified framework for few-shot evaluation of language models (MMLU, HumanEval-class tasks, 60+ benchmarks; project README, GitHub). Accessed August 2026. publisher · read in our library knowledge/fetched/cmp_modelwright_lm-eval.html · pin hb67a0fef3d08e781f2a2093997dde3f809f793714a5638dc0355a6823dfd4455 · accessed 2026-08-18 · vendor-docGrounds: The Standardized eval harness (MMLU / HumanEval) row: lm-eval-harness is the field standard the nx_eval_harness contract is measured against; ours is qabench (referee census), not a model-eval harness.

generated by nx_swcompare_matrix (sovereign NishiLang organ) from knowledge/compare/modelwright.matrix · source checks show implementation presence; runtime and user-outcome evidence are reported separately · JavaScript supports page controls