formal-blocks · def:lambda-monotone

For two agent functions $f, g$, define pointwise meet $(\Lambda_1 \wedge \Lambda_2)_i := \min(\lambda_{1,i}, \lambda_{2,i})$. The system satisfies \emph{$\Lambda$-monotone composition} when \begin{equ


formal-blocks · theorem:(Closure Dominance, Conjecture

(Closure Dominance, Conjecture). — **The Self-Grading Loop as Revelation Mechanism:** The `evaluate-all` endpoint provides the revelation mechanism: before `submit_result`, the agent POSTs its own out


formal-blocks · def:verifiable-governability

A system \(S\) is \emph{verifiably governable} if and only if: \begin{enumerate} \item Every action $a$ produced by $S$ is associated with a receipt $r \in \mathcal{R}$ carrying a $\Lambda$-score $\La


formal-blocks · cor:interpretability

For any agent output $x \in \mathcal{A}_9$: \begin{equation} \min_i x_i \;\le\; \Lambda_9(x) \;\le\; \max_i x_i. \end{equation} This is the primary interpretability guarantee of the $\Lambda$-gate.


formal-blocks · thm:lambda-monotone

The geometric-mean aggregator satisfies $\Lambda$-monotone composition: if composed output scores $z_i \ge \min(x_i, y_i)$ componentwise, then $\Lambda(z) \ge \Lambda(x) \wedge \Lambda(y)$. \textup{Le


formal-blocks · thm:no-nchv

\begin{equation} \forall\, f \colon \mathrm{Fin}\,18 \to \mathrm{Bool},\; \mathrm{ExactlyOnePerContext}(f) \implies \bot. \end{equation} \textup{Lean:} \texttt{Lutar/TwoWitness.lean}, \texttt{no\_NCHV


formal-blocks · thm:zero-sorry-target

Merging PR~\#56 (rebased) and PR~\#66 (fifth-pass drift fix) reduces the \texttt{sorry} count from 59 to $\le 10$, with the remaining sorrys confined to the \texttt{Topology/PersistentHomologyChain.le


formal-blocks · def:lambda-mp

\begin{equation} \Lambda^{(v)}_{\ell+1} \;:=\; \Lambda_k\!\Bigl(\bigl\{\Lambda^{(u)}_\ell : u \in \mathcal{N}(v)\bigr\}\Bigr). \end{equation} \textup{Source:} v18.13 PyG graft, \texttt{LambdaMessagePa


formal-blocks · theorem:(Λ₁₀ closure).

(Λ₁₀ closure). — *Proof.* (⇐) If every M_{k,j} = 1 then ∏_j M_{k,j} = 1 for all k, so A_k = L_k and Σ A_k = Σ L_k.


formal-blocks · thm:thv18-04

\begin{verbatim} theorem th_v18_04_egyptian_weight_sum (k : Nat) (hk : 0 < k) : (Finset.range k).sum (fun _ => (1 : Rat) / k) = 1 \end{verbatim}


formal-blocks · thm:nist-rmf-functor

Define categories $\mathbf{RMF}$ (objects: GOVERN, MAP, MEASURE, MANAGE; morphisms: tier-inclusion maps) and $\mathbf{\Lambda}$ (objects: $\mathrm{Fin}\,9$; morphisms: monotone maps on $[0,1]^9$). The


formal-blocks · thm:thv18-11

\begin{verbatim} theorem th_v18_11a_const_stabilizes (c : Nat) : forall n, (fun _ => c) n = (fun _ => c) 0 \end{verbatim}


formal-blocks · thm:thv18-13

\begin{verbatim} theorem th_v18_13a_id_monotone : IsNatMonotone id theorem th_v18_13b_const_monotone (c : Nat) : IsNatMonotone (fun _ => c) \end{verbatim}


formal-blocks · III.3b

The uniform weight vector (1/k, …, 1/k) is a probability vector. Governance significance: the A3 weights are the maximum- entropy prior — no axis is assumed to dominate any other. Any deviation from 1


formal-blocks · A3

Egyptian inspectability — > The standard weight set is a multiset of unit fractions \(\{1/n_k\}\) with each \(n_k\) a positive integer, summing exactly to 1 in rational arithmetic. The aggregator \(\L


formal-blocks · thm:total-order

The set $\mathcal{R}^*$ of all Ouroboros receipts, ordered by hash-chain precedence $r \prec r'$, forms a \emph{total order}. \textup{Lean:} \texttt{Lutar/SBOMProvenance.lean} (theorem \texttt{sbom\_l


forge-index · TH-V18-08-KHIPU

Khipu receipt tree checksum invariant as v18 thesis module. Derives from TH11.


forge-index · A1

If every axis improves, Λ does not decrease.


forge-index · TH-SBOM

SBOM-component receipt total-order and dual-witness drift theorems. P1-IQT-SBOM-SUM-IS-NOT-HASH remediated (uses HMAC not arithmetic sum).


forge-index · TH-REF-VECTORS

Lean Float Λ implementation matches TypeScript runtime on curated reference vectors in reference-vectors.json.


forge-index · TH-TH8-LINEAR-RECEIPT

Linear receipt module: receipt chain forms a free module over the Λ-semiring.


forge-index · TH-V18-01-LOOP

Under DPI-bounded turn budget b, Λ-gated agent state machine reaches Done in finitely many steps. Pure structural termination on Nat. Zero axiom.


forge-index · TH-V18-14-SHA256

Documents A15 as OPEN PROBLEM (P ≠ NP assumption). Audit-integrity theorems proved conditional on A15. Honest axiom under B2 discipline.


forge-index · TH-LAMBDA-RING

Λ-gate composition forms a commutative semiring under pointwise product and max.


forge-index · TH-POSITION-AWARE

Position-aware Λ gate: axis weight reflects ordinal position in receipt sequence.


forge-index · TH-HORUS-EYE

Horus Eye dyadic: ancient Egyptian fractional representation Σ 2^(-i) for i ∈ {1,2,4,8,16,32}.


forge-index · TH-PATH-INTEGRAL

Audit sum over all paths equals the Feynman path integral discretization. Largest file in repo (22KB).


forge-index · TH-TOPOLOGY-PH

Persistent homology chain for receipt topology: Betti numbers track connected components in audit DAG.


forge-index · TH-DOCTRINE-CROSS

Doctrine v6 cross-component invariant: all subsystems share the same Λ gate contract.


forge-index · A4

min_i(x_i) ≤ Λ(x) ≤ max_i(x_i).


forge-index · TH1

Λ_k(x₁,...,x_k) := (∏ x_i)^(1/k) — the weighted geometric mean with unit-fraction weights.


forge-index · TH6-MERKLE

leafCount ≤ B^height for B-ary Merkle tree; height ≤ log_B(leafCount). Structural log-height bound for receipt DAG.


forge-index · TH-QEC-CSS

CSS code bridge: classical codes C₁ ⊂ C₂ → valid CSS quantum code with distance ≥ min(d₁,d₂).


forge-index · TH-V18-10-LISTSUM

List.sum is preserved under the khipu encoding map. Structural induction.


forge-index · TH-TH8-MONAD

Receipt monad satisfies strong monad identity laws (unit, associativity).


forge-index · TH-QEC-KITAEV

Kitaev surface code toric boundary conditions: code distance scales as √n for n qubits.


forge-index · TH-GRAPH-LAMBDA

GraphLambda GNN governance head: Λ-gate applied to graph-structured receipts.


forge-index · TH10

Any function satisfying A1–A4 equals Λ_k (the geometric mean). Proof via Cauchy 1821 functional equation + Aczel 1966.


forge-index · TH-V18-02-DOCTRINE

DoctrineLabel has exactly 4 elements as a Fintype. Prerequisite for TH-V18-03 Kraft inequality.


forge-index · R4-C2

Inscribed n-gon sequence π_n is monotone increasing and bounded above by π, hence convergent. Skeleton with tagged sorry deferring to MCT.


forge-index · TH-PRNG-K10

K10v2 PRNG: deterministic replay root guarantees reproducible receipt seeding.


forge-index · TH-PAC-NONVACUOUS

pacBayesBound_nonvacuous_iff: bound is nonvacuous iff KL < n·(1 - risk)·log(1/δ) condition holds.


forge-index · R3-G1

Newton-Heron sqrt iteration is a Banach contraction on [√S,∞) with Lipschitz ≤ 1/2. Lineage hook for TH12 DPO stability.


forge-index · R2-G6

For round-trip (g∘f = id), contentId is preserved. Complete proof, zero sorry. Khipu transcription analogy.


forge-index · TH-MATCHED-FILTER

Matched filter maximizes SNR for receipt correlator under AWGN.


forge-index · TH-SEXAGESIMAL

A positive integer n is sexagesimally regular iff n | 60^k for some k. Babylonian table of reciprocals is regular.


forge-index · TH-V18-16-FEYNMAN-INT

Citation integrity: feynman citation chain contains no duplicates and references are non-empty.


forge-index · TH-LAMBDA-SCHUR

Λ_k is Schur-concave: for majorization x ≻ y, Λ(x) ≤ Λ(y). This captures fairness under redistribution.


forge-index · TH-BRAHMI-AXIS

Brahmi axis AxisOption models the positional-zero digit enabling subtraction completion.


forge-index · TH-V18-06-BRAHMI

Brahmi positional-zero gate: AxisOption none represents the zero-axis identity element.


forge-index · R4-I1

Generic Madhava-Leibniz remainder: |Σ_{n=0}^{N} a_n - L| ≤ a_{N+1} for monotone-decreasing alternating series.


forge-index · TH-OVERWATCH

OVERWATCH read-only gate: observation does not mutate receipt state.


forge-index · TH-GLEASON

Doubly-even self-dual binary codes have length ≡ 0 (mod 8). SZL governance analog for 8-receipt closure invariant.


forge-index · TH-PAC-MONO

PAC-Bayes bound is monotone increasing in KL divergence.


forge-index · TH-V18-13-DPI

Abstract DPI bound as v18 module, parameterized over receipt channel type.


forge-index · TH-COMP

If S₁ is (δ,ε₁)-robust and S₂ is (ε₁,ε₂)-robust, then S₁∘S₂ is (δ,ε₂)-robust. Zero axiom, zero sorry.


forge-index · TH-V18-09-PERM

Λ is invariant under permutation of axes: Λ(σ(x)) = Λ(x) for any σ ∈ Sym(k).


forge-index · TH-TWO-WITNESS

TH KS-18: 18-vector Kochen-Specker proof that no non-contextual hidden-variable model exists in ℝ³.


forge-index · TH-V18-15-FAIRNESS

In cooperative multi-agent system with finite fuel per agent, the system terminates. Foundational liveness for v18.x MultiAgentOrchestrator.


forge-index · TH-COMP-TH1

TH1 composition master theorem: sequential Λ-gate composition preserves monotonicity and boundedness.


forge-index · TH-QEC-HAMMING

Hamming distance triangle inequality and sphere-packing bound for quantum receipt encoding.


forge-index · TH-V18-11-PARETO

Non-decreasing bounded Nat sequence stabilizes. Classically true; deferred to Nat.find with decidable predicate. TRACKED.


forge-index · TH-TH8-GRADED-SEMIRING

Graded semiring of Λ-receipts indexed by trust level ∈ {0,1,2,3}.


forge-index · TH2

min_i(x_i) ≤ Λ_k(x) ≤ max_i(x_i). Machine-checked via Mathlib4 geometric-mean reasoning.


forge-index · TH6-DPI-SOUND

Master DPI soundness theorem tying receipt chain to entropy monotonicity.


forge-index · TH-V18-01-MONO

Λ-gate monotonicity restatement as v18 module theorem.


forge-index · TH-RELAY-CHAIN

Inca relay-runner (chasqui) chain: message propagates through relay stations preserving content identity.


forge-index · TH6-SCITT

Entropy lower bound for SCITT receipt masks under DPI constraint.


forge-index · TH-CRT-WEIGHT

Chinese Remainder Theorem applied to receipt weight chunking: disjoint-modulus chunks reconstruct unique weight.


forge-index · A2

Λ(c·x) = c·Λ(x) for scalar c ≥ 0.


forge-index · TH-PUBLIC-CLAIMS

Authoritative source of truth for all publicly-claimed Lean theorems. Each entry maps (Lean theorem, runtime counterpart, doctrine doc citation).


forge-index · TH2b

min_i(x_i) ≤ Λ_k(x). Companion to TH2.


forge-index · TH-V18-07-FEYNMAN

Citation chain from Feynman diagrams to SZL receipt audit has length ≥ 1.


forge-index · TH-R1-TESTS

Lean-level tests for R1 composition properties against reference vectors.


forge-index · TH-SHANNON

Doctrine alphabet has 4 labels; Shannon 2-bit code is optimal (H=2 bits for uniform source). Kraft equality holds.


forge-index · TH-REIDEMEISTER

Three audit-Reidemeister rewrites R1 (repack), R2 (commute), R3 (associativity). CONJECTURE status; all sorry-tagged; target v16.


forge-index · TH-EGYPTIAN-AKHMIM

Akhmim RMP 2/n table: unit-fraction decomposition of 2/n for odd n ≤ 101. Formal proof of table correctness.


forge-index · TH-V18-03-KRAFT

4 codewords × 2^(-2) = 1. Code is Shannon-optimal for uniform 4-symbol source. Proof by norm_num.


forge-index · TH13

Closed-form non-vacuous PAC-Bayes bound for governance head. Arithmetic content fully formalised; probabilistic Pr ≥ 1-δ quantifier deferred.


forge-index · TH-DOCTRINE-ENTROPY

Measurability honesty: all doctrine labels are measurable under the sigma-algebra induced by Λ.


forge-index · TH12

Policy-loop rollback step is stable under DPO via Pinsker + Lipschitz composition. Three tagged sorrys: Pinsker (Mathlib), Lipschitz from Ch.9 gate boundedness.


forge-index · TH6

Elementary Cover-Thomas DPI (Theorem 2.8.1). NOT the Bekenstein physical bound (F1-4 retraction documented in CHANGELOG). Receipt chain H(X|Z) ≤ H(X|Y) for Markov chain X→Y→Z.


forge-index · TH-QEC-SHOR

Shor 9-qubit code structure applied to receipt encoding: corrects any single-qubit error.


forge-index · A3

Λ(c,c,...,c) = c for all c (diagonal commitment S1). Replaces vacuous tautology flagged in PhD-Math V14-C1.


forge-index · TH-FEYNMAN

feynmanToSZLChain.length = 4 (Feynman → quantum → information → SZL). chain_citations_nonempty.


forge-index · TH-ADINKRA

Adinkra graph supersymmetry invariant for gate receipt topology.


forge-index · TH-HALT-ELIG

An agent is halt-eligible iff its receipt DAG is closed under DPI and all pending receipts have been acknowledged.


forge-index · TH-MORAL-GROUNDING

Moral grounding: any doctrine-compliant agent satisfies the honesty + measurability constraints.


forge-index · TH-V18-05-TRANSDUCTION

Transduction preserves receipt content integrity under encode-decode round-trip.


forge-index · TH-V18-04-EGYPT

Egyptian unit-fraction weights sum to 1: Σ_{i=1}^k (1/k) = 1.


forge-index · TH11

Three-tier khipu receipt DAG: primary = Σ pendants, pendant = Σ sub-pendants. Receipt-tree coboundary integrity.


forge-index · TH-COMP-OVERHEAD

Composition overhead: adding k layers multiplies Λ gate latency by at most k·(1+ε).


forge-index · TH-V18-12-LAMBDA-PROD

Λ_k product formula: (∏ x_i)^(1/k) expressed as composition of ring operations.


forge-index · TH-WHEELER

Wheeler window safety: receipts outside admission window are rejected; closeLabel is a function of admission. Idempotent.


forge-index · R1-G1

Egyptian aha method: for affine gate f(x) = mx+c, false_position_correct recovers target exactly from two samples.


forge-index · TH-TH8-GLR

Graded linear receipt semiring: receipts graded by trust level form a valid semiring.


formula-ledger · TH_V18_03-kraft

Kraft inequality: for a binary prefix code with lengths {1,2,3,3}, sum 2^{-l_i} = 1 <= 1 (complete code equality).


formula-ledger · lambda-score-dimensionless

Trust axes x_i in [0,1] are dimensionless; Lambda (weighted geo-mean of dimensionless axes) is dimensionless.


formula-ledger · bekenstein-dimensional

Bekenstein bound S = 2*pi*R*E/(hbar*c): the group R*E/(hbar*c) must be dimensionless.


formula-ledger · shor-913-distance

Shor code [[9,1,3]]: distance d=3 corrects t=floor((d-1)/2)=1 error; satisfies classical Singleton n-k+1=9 >= d.


formula-ledger · k-verify-accuracy

Model accuracy / khipu-verifiability / HUKLLA refusal, scored against 100 public-source Q&A items.


formula-ledger · landauer-energy

Landauer limit E = k_B * T * ln2: energy per irreversible bit erasure has units of energy (Joules).


formula-ledger · F0003-receipt-edge

A receipt-bound edge e in E is a tuple (a_src, r_src, r_dst, ...).


formula-ledger · byzantine-n3f1

BFT arithmetic: with f=1 faulty, n=3f+1=4 nodes and quorum 2f+1=3 (the 3-of-4 Khipu quorum). NOTE: BFT *safety/liveness* itself is Conjecture-2/3, not proven.


formula-ledger · A4-bounded-amgm

Geometric mean <= max axis (AM-GM corollary). 2-var: sqrt(a*b) <= (a+b)/2, with slack (sqrt(a)-sqrt(b))^2/2.


formula-ledger · pinsker-2pt

Pinsker: KL(p||q) >= 2*TV(p,q)^2. Machine-checked by numeric sampling over random 2-point distributions (NOT a symbolic proof).


formula-ledger · F12-kuramoto-additive

Additive superposition fragment: total coupling over k phases = sum of per-phase couplings (linear part only; NOT nonlinear Kuramoto sync).


formula-ledger · K13-bekenstein-fire

Bekenstein indicator fire rate = 49.5% (thesis.md 4.5).


formula-ledger · madhava-leibniz-atan

Madhava-Leibniz series: atan(x) = sum_{m>=0} (-1)^m x^(2m+1)/(2m+1); matches sympy Taylor series of atan.


formula-ledger · K06-rho-closure

rho-closure rate = 100% (8000/8000 paired calls, ouroboros v6.3.0).


formula-ledger · F18-reed-solomon-singleton

Singleton bound: min distance d <= n-k+1; RS(10,6) tolerates n-k=4 erasures, recoverable iff >=6 of 10 shards survive.


formula-ledger · F1-euler-khipu-chi

Euler characteristic of a convex polyhedron: V - E + F = 2 (checked on the Platonic solids).


formula-ledger · conjecture-2-khipu-safety

Khipu BFT 3-of-4 safety: no two conflicting decisions both reach quorum under <=f faults.


formula-ledger · F0001-system-tuple

System defined as tuple S = <R, A, E, Lambda, rho, W> over eight regions.


formula-ledger · TH_L1-lambda-uniqueness

Conjecture 1: Lambda (weighted geo-mean w/ Egyptian weights) is the UNIQUE aggregator satisfying A1-A5. Unconditional uniqueness is machine-checked FALSE (maxAgg counterexample); conditional Theorem U is proven.


formula-ledger · TH_V18_04-egyptian-horus

Horus-Eye / Egyptian unit-fraction sum: 1/2+1/4+1/8+1/16+1/32+1/64 = 63/64.


formula-ledger · code-of-reality-lineage

'Code of reality' / ancient-text inspiration (Emerald Tablet correspondence, Dead Sea Scrolls calendrics) as substrate metaphor.


formula-ledger · conjecture-3-khipu-liveness

Khipu BFT liveness: every submitted action eventually reaches a quorum decision.


formula-ledger · F19-bekenstein-additive

Entropy budget additive & monotone over a region partition: s1 <= s1 + s2 for s2 >= 0 (NOT the full Bekenstein bound).


formula-ledger · axis-schema-13

Canonical 13-axis trust vector: 2 sacred (floor 0.95) + 7 structural (0.90) + 4 introspection (0.90).


formula-ledger · A2-homogeneity

Weighted geometric mean is positively homogeneous degree 1: Prod (c*x_i)^{w_i} = c * Prod x_i^{w_i} when sum(w_i)=1.


formula-ledger · quadratic-completion

Completing the square: x^2 + b*x + c = (x + b/2)^2 + (c - b^2/4).


formula-ledger · cauchy-schwarz-2d

Cauchy-Schwarz (n=2) via Lagrange identity: (a1*b1+a2*b2)^2 = (a1^2+a2^2)(b1^2+b2^2) - (a1*b2-a2*b1)^2, so LHS <= product.


formula-ledger · dsse-envelope-struct

DSSE envelope structure with PAE binding; signature is an HONEST PLACEHOLDER (Sigstore not wired).


formula-ledger · fisher-rao-identity

Fisher-Rao distance d(p,q) = 2*arccos(sum sqrt(p_i q_i)); self-distance d(p,p) = 2*arccos(1) = 0 when sum p_i = 1.


formula-ledger · K01-receipt-build-latency

Receipt build p50 = 11.5 us (62764 ops/s), p99 = 50.7 us; verify p50 = 1e6/ops_per_sec.


Arithmetic-intensity-guided CPU/GPU offloading

KTransformers keeps only high-arithmetic-intensity ops (MLA attention ~512, shared experts, projections, embeddings-on-CPU) on the GPU and pushes the routed-MoE experts — a batch-1 GEMV with arithmetic intensity ~0.075, and 96% of the parameters — onto the CPU/DRAM. This is precisely how they run DeepSeek-V2 (236B) in ~21GB VRAM + 136GB DRAM. For SZL this is THE thesis for making szl-nemo (a MoE) servable on the RTX 4060 Ti tower: split by intensity, not by naive layer count, so the small VRAM holds the hot dense path while cold experts live in system RAM.

Applies to: szl-nemo.

Evidence: doc/en/deepseek-v2-injection.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/deepseek-v2-injection.md)


Declarative YAML injection / op-replacement (per-node tuning as config, not code)

Instead of forking model code, KTransformers matches modules by name-regex AND/OR class and swaps optimized backends via a YAML rule file (match/replace/kwargs with generate_device, prefill_op, generate_op, out_device). Device placement, quant kernel choice, and multi-GPU layer splits are all data. For SZL's heterogeneous fleet (tower vs laptop vs szl-nemo) this means one model definition + a per-node rule file — the forge recipe should emit a machine-specific placement YAML rather than bespoke code per box.

Applies to: sovereign-serving.

Evidence: doc/en/SFT/injection_tutorial.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/SFT/injection_tutorial.md)


3-layer (GPU-CPU-Disk) prefix-cache reuse for failover latency

balance_serve stores and reuses KVCache across a GPU→CPU→disk hierarchy (config: kvc2.gpu_only=false, cpu_memory_size_GB, disk_path). Repeated system prompts / agent scaffolds hit cached prefixes instead of re-prefilling. For SZL this is the single biggest failover-latency lever: when a request re-routes to the tower, a warm prefix cache turns a cold multi-thousand-token prefill into a near-instant continuation, and the disk tier survives process restarts.

Applies to: sovereign-serving.

Evidence: doc/en/prefix_cache.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/prefix_cache.md)


balance_serve: C++ continuous batching + chunked prefill + variable-batch CUDA Graph

A 10k+-line refactor (inspired by SGLang) split KTransformers into Server / Inference-Engine / Scheduler layers, adding FCFS continuous batching, chunked prefill, and a variable batch-size CUDA Graph (via their custom_flashinfer fork) that cuts padding/memory overhead. Reported ~130% throughput at 4-way concurrency. For SZL sovereign serving under concurrent agent load, continuous batching + chunked prefill is the pattern that stops one long prompt from head-of-line-blocking the fleet.

Applies to: sovereign-serving.

Evidence: doc/en/balance-serve.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/balance-serve.md)


CPU-GPU expert scheduling with frequency-based placement

kt-kernel exposes a GPU-expert mask with four placement strategies — uniform, frequency (put most-activated experts on GPU using --init-expert-location activation stats), front-loading, random — plus --kt-num-gpu-experts. This lets you spend scarce VRAM on exactly the experts that fire most. For szl-nemo on a 24GB-class card: profile activation on SZL's real workloads, then pin the hot experts to GPU and leave the long tail on CPU — a measured, data-driven use of the tower's limited VRAM.

Applies to: szl-nemo.

Evidence: doc/en/kt-kernel/experts-sched-Tutorial.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/kt-kernel/experts-sched-Tutorial.md)


MLA matrix-absorption to shrink the KV cache

DeepSeek's Multi-head Latent Attention keeps a joint compressed KV representation; KTransformers absorbs the decompression matrices into q_proj/out_proj so attention runs on the compressed form — never materializing the decompressed KV. This both shrinks the KV cache and raises the operator's arithmetic intensity so the GPU is well-utilized. Relevant to SZL's corpus of forge recipes: if szl-nemo adopts an MLA-style attention, absorption is the trick that makes long-context serving fit small VRAM.

Applies to: szl-nemo.

Evidence: doc/en/deepseek-v2-injection.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/deepseek-v2-injection.md)


Runtime CPU-capability detection with honest fallback (build-once-run-anywhere)

The kt-kernel PyPI wheel ships six CPU variants (AMX, AVX512+BF16/VBMI/VNNI/Base, AVX2) and auto-selects the best at import; CUDA features auto-disable when no supported GPU is present, and old CPUs fall back to AVX2. This capability-detect-then-fallback pattern (overridable via KT_KERNEL_CPU_VARIANT) is exactly what SZL's forge distribution should do: one artifact that measures the host and degrades honestly rather than shipping a box-specific binary that silently misbehaves elsewhere.

Applies to: forge-training.

Evidence: kt-kernel/README.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/kt-kernel/README.md)


Quantized-weight kernels that operate directly on GGUF/quant data (Marlin GPU + llamafile CPU)

KTransformers runs quant kernels (Marlin on GPU, llamafile/CPUInfer on CPU using AVX512-BF16 / AVX-VNNI) directly on quantized weights, avoiding the dequantize-to-BF16 round-trip that HF Transformers pays. Marlin reports ~3.87x over Torch. SZL's fleet already runs q4 GGUF (tower's llama3-szl-finetuned-q4); the lesson is to serve with kernels that consume the quant format natively so the q4 win isn't erased by on-the-fly dequant memory traffic.

Applies to: sovereign-serving.

Evidence: doc/en/deepseek-v2-injection.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/deepseek-v2-injection.md)


Phase-aware kernel switching + MoE fusion + work-stealing (AMX/AVX-512)

On AMX-class CPUs KTransformers rearranges expert weights into 64-byte-aligned tile-friendly blocks (cache-resident in L2/L3), fuses each layer's Gate+Up projections into two unified tasks, and dynamically switches AMX (prefill, >4 tokens/expert) vs a lightweight AVX-512 kernel (decode/short prompts), with atomic task-stealing to absorb expert-activation skew — reaching 21 TFLOPS BF16 / 35 TOPS INT8 on Xeon4. Honest bound for SZL: the tower is a consumer box likely without AMX, so the direct win is the AVX-512 decode path + fusion mindset, not the AMX tiles; revisit tiling only if SZL provisions Sapphire-Rapids+ metal.

Applies to: forge-training.

Evidence: doc/en/AMX.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/AMX.md)


Selective expert activation as an explicit speed/quality knob

KTransformers benchmarks show running fewer routed experts (6 vs the model's default 8) raises DeepSeek-V3 prefill/decode throughput measurably (e.g. up to 286 vs 255 tokens/s prefill in V0.3-preview) at some quality cost. This is a real, honest latency lever — but it changes model behavior, so SZL must surface it as a DECLARED tuning choice with measured throughput deltas, never as a free win. Useful for the forge recipe when a node is throughput-bound.

Applies to: sovereign-serving.

Evidence: doc/en/DeepseekR1_V3_tutorial.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/DeepseekR1_V3_tutorial.md)


Compiler stack, NOT a drop-in for ollama (honest applicability boundary)

ZML is an ahead-of-time compile-to-hardware inference stack (Zig + MLIR/OpenXLA/PJRT, built with Bazel) that decouples models from proprietary hardware — 'Any model, many hardwares, one codebase'. It is NOT a drop-in for SZL's ollama/llama.cpp GGUF fleet: adopting it as a runtime needs a full bazel+Zig toolchain and per-model porting. Honest stance: not applicable as a runtime today; revisit when SZL needs multi-vendor peak-perf serving (e.g. mixing NVIDIA + AMD/Intel nodes) beyond what ollama offers.

Applies to: sovereign-serving.

Evidence: https://raw.githubusercontent.com/zml/zml/master/README.md


PJRT single-enum platform-capability abstraction

One `Platform` enum {cpu, cuda, rocm, tpu, neuron, oneapi, metal} with a single `load(tag)` that dispatches to the matching per-vendor PJRT plugin, plus `isEnabled(tag)`. This is a clean portability contract SZL can mirror in its own node-capability probe: enumerate a node's real backends and dispatch, rather than assuming CUDA everywhere. Adoptable as a design pattern even without adopting ZML's runtime.

Applies to: sovereign-serving.

Evidence: https://raw.githubusercontent.com/zml/zml/master/platforms/platforms.zig


zml-smi: vendor-neutral accelerator telemetry with Prometheus exposition

A standalone monitor (bin/zml-smi) probes NVML/amdsmi/oneAPI/Neuron/TPU/macOS/Linux and exposes unified `zml_device_*` Prometheus metrics (utilization, memory used/total, power_watts, temperature, fan, clocks, PCIe throughput; per-vendor extensions like Neuron core memory breakdown) via `--prometheus-listen HOST:PORT`, plus TUI/CSV/JSON. Directly transferable technique for SZL fleet observability of the tower (RTX 4060 Ti class): scrape GPU utilization/power/mem/temp into the same honest MEASURED telemetry surfaces.

Applies to: sovereign-serving.

Evidence: https://raw.githubusercontent.com/zml/zml/master/bin/zml-smi/prometheus/exposition.zig


Compile-once Executable + weight loading parallelized for cold-start latency

ZML's model lifecycle separates model compilation (struct + forward() → accelerator-specific `Executable`) from weight loading (disk → accelerator `Buffer`), and explicitly notes both are startup bottlenecks that run in parallel via Zig's std.Io. The insight matters for a szl-nemo node: cold-start latency is dominated by compile + weight-load, and overlapping them (or caching the compiled artifact) is the lever — even under ollama, pre-warming/keeping the model resident attacks the same bottleneck.

Applies to: szl-nemo.

Evidence: https://raw.githubusercontent.com/zml/zml/master/docs/learn/concepts.md


Hermetic cross-compile + distroless OCI single-binary packaging

Bazel cross-compiles from the dev machine to linux_amd64/linux_arm64/macos_arm64 targets and emits either a zstd TAR (scp + run) or a distroless OCI image (rules_oci: oci_image/oci_load/oci_push over @distroless_cc_debian12, forced to linux_amd64 via platform_transition_filegroup), with weights bundled as bazel data deps and an expand_template entrypoint. The reproducible, hermetic, single-binary packaging discipline is worth adopting for SZL deployable artifacts regardless of runtime — no interpreter/venv drift on the target.

Applies to: sovereign-serving.

Evidence: https://raw.githubusercontent.com/zml/zml/master/docs/howtos/dockerize_models.md


Layer-wise numerical porting/verification (torch2zml + testLayer)

ZML's model-porting methodology loads safetensors into a TensorStore, builds typed layer structs (zml.nn.Linear etc), and verifies each layer numerically against reference activations dumped from the Python reference using `zml.testing.testLayer` — with an error taxonomy (compile / buffer-not-found naming mismatch / MLIR math error) and the discipline of pruning unused reference code paths first. The per-layer activation-diff verification loop is transferable to SZL's forge recipe when porting or fine-tuning a model, to catch subtle math/quantization regressions before serving.

Applies to: forge-training.

Evidence: https://raw.githubusercontent.com/zml/zml/master/docs/howtos/howto_torch2zml.md


Two-layer profiling: host trace scopes + backend XSpace→Perfetto, with external-profiler co-existence

ZML splits profiling into host tracing (`zml.tracer.scope()` emitting NVTX/ROCTx/os_signpost) and backend profiling (`Platform.profiler()` → XSpace protobuf streamed to Perfetto trace.json), and cleanly co-exists with external profilers (nsys/rocprofv3/neuron-profile) by setting SKIP_PJRT_PROFILER=true to avoid double sessions. The pattern — lightweight always-on host scopes plus opt-in deep backend capture, joined only at session end — is a good model for how SZL should instrument its serving loop without paying full-profiler overhead per request.

Applies to: sovereign-serving.

Evidence: https://raw.githubusercontent.com/zml/zml/master/docs/howtos/profiling.md


Profile is a synthetic/template repo farm — study-only, adopt nothing as-is

All 57 repos were pushed in a single burst (2026-06-29/30), carry grand buzzword descriptions (multi-cloud orchestration, blockchain, AI), yet the actual code is trivial scaffolding generated from a shared template. ModelRelay's 'framework' is an empty argparse+logging CLI stub whose body is literally '# Add your main logic here'; MetaStack's 'multi-cloud orchestrator' is a client-side to-do list; SignalNexus ships no code at all (LICENSE+README only). For SZL this is a negative finding: there is no substantive engineering here to distill.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/glesmyno/ModelRelay/HEAD/modelrelay.py


Description-vs-implementation gap is a reusable spam/synthetic-repo signal

The systematic mismatch between inflated READMEs ('Innovative MetaStack orchestrates multi-cloud deployments with seamless zero-downtime updates') and trivial implementations (an add/remove item list) is exactly the pattern SZL's frontier ingestion and honesty audit should learn to down-rank. A cheap heuristic — README claim entropy vs. real LOC/imports/tests — would keep synthetic portfolios out of MEASURED/REPORTED leaderboards.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/glesmyno/MetaStack/HEAD/src/components/MetastackContainer.jsx


Star counts here are not evidence of substance — weight by real content

Top repos by stars (MetaStack 46, ModelRelay 38, SignalNexus 34) are the same empty scaffolds; SignalNexus has 34 stars and zero source files. 280 total stars across 57 repos with no forks and near-zero issues reads as inorganic. SZL's frontier/leaders ranking should never treat raw stars as a quality proxy without a content/forks/issues cross-check.

Applies to: frontier.

Evidence: https://api.github.com/repos/glesmyno/SignalNexus/git/trees/HEAD?recursive=1


MIT license present — reuse permitted, but nothing worth reusing

Every repo carries an identical 1061-byte MIT LICENSE, so reuse is legally permitted (attribution still required by SZL doctrine). The only mildly reusable artifact is ModelRelay's conventional Python CLI skeleton (argparse + configured logging + type hints), a fine boilerplate for a throwaway forge harness but neither novel nor SZL-specific. Not adopted; noted only for completeness.

Applies to: forge-training.

Evidence: https://raw.githubusercontent.com/glesmyno/ModelRelay/HEAD/LICENSE


Same synthetic template farm as glesmyno — likely the same operator

All 65 repos pushed in one burst (2026-06-29/30), all MIT, all original (no forks). CipherTrace.py ('AI-driven Automated Sanctions Screening') is byte-for-byte the same empty CLI stub as glesmyno/ModelRelay.py down to the '# Add your main logic here' comment and identical logging setup. The identical LICENSE byte-size (1061), README template, and stub code across both accounts indicate a shared generator. Honest conclusion: treat glesmyno + yunawyner as one synthetic cluster, study-only, adopt nothing.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/yunawyner/CipherTrace/HEAD/ciphertrace.py


Cross-account template correlation → a dedup/cluster heuristic for SZL frontier

Because both profiles emit identical stub code and README scaffolding, a content-hash / template-fingerprint check would let SZL's frontier ingestion collapse such clusters and refuse to double-count them as independent 'leaders'. This is a concrete honesty-preserving heuristic worth building into the source registry, not a technique borrowed from the repos themselves.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/yunawyner/CipherTrace/HEAD/LICENSE


ProofSignal's retry-with-exponential-backoff is the only genuine (but generic) micro-pattern

ProofSignal.js contains a real, correct retry helper (N attempts, throw on final failure, 1000*(i+1)ms linear backoff). It is generic and unremarkable, but it is the single piece of non-empty logic found across ~120 repos. SZL's sovereign-serving failover already needs bounded-retry-with-backoff when a node's /v1/models probe times out; this merely confirms the shape — SZL should author its own (jittered exponential) version, MIT attribution noted, not copy this one.

Applies to: sovereign-serving.

Evidence: https://raw.githubusercontent.com/yunawyner/ProofSignal/HEAD/src/proofsignal.js


Inflated compliance/security claims with empty bodies — hard honesty-filter case

CipherTrace claims 'AI-driven Automated Sanctions Screening' and FortiGuard claims an 'Intelligent Threat Defense Gateway', yet both are 1.6KB no-op stubs (FortiGuard's extra 118KB is a committed .Logs file + packed git history, not code). Security/compliance-flavoured claims with zero implementation are exactly what SZL's honesty audit must catch before any such source could touch a MEASURED/REPORTED surface.

Applies to: frontier.

Evidence: https://api.github.com/repos/yunawyner/FortiGuard/git/trees/HEAD?recursive=1


The Λ invariant's formal spine lives HERE — Alloy now surfaces it, never re-proves it

lutar-lean defines the Λ aggregator (geometric-mean trust score over provenance/containment/coherence/convergence), the LutarAxioms A1–A5, and kernel-checks the theorems the runtime relies on (bounds, monotonicity, permutation-invariance, hash-chain tamper-evidence, quorum agreement). Its own machine counter reports 1323 declarations / 22 unique axioms / 254 non-comment sorries at the locked v11 baseline, with the locked-proven formula set frozen at exactly 8 {F1,F4,F7,F11,F12,F18,F19,F22} (re-locked 2026-06-10 when F4/F7 gained genuine proofs; enforced by the no-axiom theorem locked_count_eight). Alloy's GET /lean window is a REPORTED pass-through of these numbers plus a MEASURED local kernel check — it never recounts or re-badges the corpus.

Applies to: lean-ledger.

Evidence: https://raw.githubusercontent.com/szl-holdings/lutar-lean/HEAD/.github/data/lean_numbers.json


Conjecture discipline: unconditional Λ uniqueness is machine-checked FALSE and stays Conjecture-1

The repo machine-checks a maxAgg counterexample against UNCONDITIONAL Λ uniqueness; only the CONDITIONAL Theorem U chain ({A1–A5} + separability + slice-multiplicativity + slice-monotonicity) is kernel-clean on its stated hypotheses. A public bounty file is the only process that could ever close it. This is the exact pattern Alloy's doctrine banner enforces: no CI pass, no local kernel-check PASS, no panel can upgrade Conjecture-1.

Applies to: lean-ledger.

Evidence: https://github.com/szl-holdings/lutar-lean/blob/main/BOUNTY.md


EXPERIMENTAL_SCOPES: grow the corpus without silently moving locked numbers

Wave branches (Putnam sampler, Wave19–23) register their file scopes under EXPERIMENTAL_SCOPES in lean_numbers.py so new experimental proofs are compiled and kernel-checked by lake build but EXCLUDED from the locked v11 baseline counts. Metrics only move by explicit re-lock, never by drift. Directly applicable to every Alloy MEASURED surface: additive experiments must not silently inflate a locked headline number.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/szl-holdings/lutar-lean/HEAD/.github/data/lean_numbers.json


Split CI verdicts on the same commit are honest data, not noise

At HEAD 85dee499 the repo's own Actions history shows lake-build.yml run 499 FAILED while lean.yml run 757 PASSED on the same sha. The honest rendering is both verdicts side by side, exactly as GitHub returned them — which is what Alloy's LeanLedger CI block does. Cherry-picking the green workflow (or retrying at an older sha until green) would be fabrication by omission.

Applies to: lean-ledger.

Evidence: https://github.com/szl-holdings/lutar-lean/actions/workflows/lake-build.yml


Verify-for-yourself as a product surface — but pinned to an OLDER doctrine snapshot

lean-kernel ships a Dockerized live Lean v4.13.0 kernel so outsiders can re-run the invariant proofs themselves instead of trusting SZL's word. Crucially it is pinned to Doctrine v11 at 749 declarations / 14 axioms / 163 sorries (kernel commit c7c0ba17) while lutar-lean HEAD reports 1323/22/254 — a real, visible version skew. Any Alloy panel citing corpus numbers must state WHICH snapshot it reports; mixing the two silently would fabricate a corpus that exists nowhere.

Applies to: lean-ledger.

Evidence: https://raw.githubusercontent.com/szl-holdings/lean-kernel/HEAD/README.md


Public errata notes over silent edits (the 2026-06-30 alignment fix)

The README carries a dated correction block stating that a previously referenced HF Space (SZLHOLDINGS/lean-kernel) does not exist and pointing to the real artifact (the SZLHOLDINGS/szl-kernels model card). Correcting a false pointer publicly and datedly — rather than silently rewriting history — is the errata pattern SZL surfaces should follow when a claim is found wrong.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/szl-holdings/lean-kernel/HEAD/README.md


Machine-readable declaration inventory as an export contract

data/lean_corpus_decls.json (~283KB) enumerates the corpus declarations as data, letting downstream tools consume the proof inventory without parsing Lean source. If Alloy ever lists individual theorems, this file — not a hand-typed list — is the honest source, fetched and labeled REPORTED with its snapshot provenance.

Applies to: lean-ledger.

Evidence: https://github.com/szl-holdings/lean-kernel/blob/main/data/lean_corpus_decls.json


Tri-state harness verdicts with CI re-run on every push — receipts against drift

The harness assigns each formula CHECKED (algebra/units machine-verified THIS pass), FAILED (identity is false), or UNCHECKABLE (no honest machine check exists: empirical, definitional, or conjecture) and CI re-runs it on every push so no claim can quietly rot. A pass is never fabricated and never carried over stale. Alloy's FormulaCodex renders this ledger as a REPORTED pass-through; the /lean window now sits beside it as the Lean-kernel counterpart.

Applies to: lean-ledger.

Evidence: https://raw.githubusercontent.com/szl-holdings/szl-formula-ledger/HEAD/README.md


A pass means EXACTLY what it checked: units-check ≠ uniqueness proof

lambda-score-dimensionless is CHECKED — but the README states outright that this is a UNITS check (the Λ score is dimensionless) and 'not a proof of the uniqueness conjecture'. TH_L1-lambda-uniqueness stays UNCHECKABLE [CONJECTURE] forever in this harness. Scoping every green badge to precisely what was verified is the discipline all Alloy MEASURED captions follow (e.g. a kernel-check PASS = 'these modules at this sha', nothing more).

Applies to: lean-ledger.

Evidence: https://raw.githubusercontent.com/szl-holdings/szl-formula-ledger/HEAD/README.md


Banned-claims enforcement at the ledger level

The repo bans perpetual-motion / zero-cost-energy / 'free energy' claims outright per estate G3 doctrine — the ledger will not carry them under any label. A denylist of claim classes that no honest label can launder is a cheap, enforceable guardrail worth mirroring in any SZL surface that accepts new formula entries.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/szl-holdings/szl-formula-ledger/HEAD/README.md


szl-lake is the DSSE receipt lake — NOT Lean's `lake` build tool (name collision resolved)

Two unrelated things share the name: Lean 4's build tool `lake` (what `lake build` runs inside lutar-lean and Alloy's local lean-lab) and szl-lake, SZL's data lake of ECDSA P-256 DSSE-signed Khipu receipts on a hash-linked Merkle DAG. The GitHub repo is the front door (README + small JSON indexes + manifest pointers); the HF dataset SZLHOLDINGS/szl-lake is canonical for the NDJSON receipt streams. Anyone can pull a receipt stream and verify signatures end-to-end.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/szl-holdings/szl-lake/HEAD/README.md


Doctrine snapshots are PINNED to a kernel commit, never floating

The lake's doctrine/ directory freezes v11 LOCKED at 749 declarations / 14 axioms / 163 sorries pinned to lutar-lean kernel commit c7c0ba17 — a diligence reviewer verifies against that exact commit, not against whatever HEAD says today. The same pin-to-sha provenance rule governs Alloy's MEASURED kernel-check artifact: it names the sha and toolchain it checked, and a fresher HEAD never silently replaces it.

Applies to: lean-ledger.

Evidence: https://raw.githubusercontent.com/szl-holdings/szl-lake/HEAD/README.md


Attestations that state what is NOT claimed

The attestations/ directory records Section 889 vendor checks, an SLSA L1-honest level record, and a supply-chain self-attestation that explicitly disclaims FedRAMP / Iron Bank / CMMC. Enumerating the certifications you do NOT hold, in the same file as the ones you do, is the strongest form of the honesty doctrine — absence declared, not implied.

Applies to: frontier.

Evidence: https://raw.githubusercontent.com/szl-holdings/szl-lake/HEAD/README.md


The agent loop is sequential — per-step speed compounds, core count doesn't help one loop

The article's central thesis: an agent advances through a chain of dependent steps (model reasons → CPU executes tool/code/data work → result feeds the next model call), so the time of EACH CPU-side step sits on the critical path and adding cores cannot shorten a single loop — only faster per-step execution can. This is directly true of Alloy's own backbone loop: routing, failover bookkeeping, meter sampling, and receipt signing all happen between model windows, serially. SZL's application is to MEASURE that orchestrator share per run (the loop tax) instead of assuming it is negligible.

Applies to: backbone-loop.

Evidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/


Loop tax made MEASURED: Alloy now splits every run into model window vs orchestrator overhead

Applied 2026-07-12: every /run result's loop block now carries modelMs (MEASURED sum of provider-attempt wall windows) and overheadMs (DERIVED: run wall − modelMs — routing, energy-meter samples, trace bookkeeping, any self-verification pass). The split reconciles exactly against the run's MEASURED latencyMs and is never claimed as pure CPU time (attempt windows include network + provider queueing). Demo runs honestly show a zero model window. This is the Vera thesis made our own: don't buy the vendor's numbers — instrument YOUR loop.

Applies to: backbone-loop.

Evidence: GET /api/run result → loop.modelMs / loop.overheadMs / loop.timingBasis


Idle compute waiting on the loop is the real cost — GPU-utilization economics

NVIDIA frames CPU slowness as an AI-factory revenue problem: every ms the CPU spends between model calls is a ms the expensive accelerator sits idle. Scaled to SZL's two-node fleet the same logic holds — when the tower GPU waits on orchestrator work (or on a dead meter tunnel costing seconds per failover attempt), sovereign serving throughput drops. Alloy already dedupes dead meter hosts per run for exactly this reason; the loop-tax metric now makes any regression of that kind visible as a rising overheadMs instead of an invisible drag.

Applies to: sovereign-serving.

Evidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/


Predictable per-step latency beats aggregate throughput for a single agent

The article's design triad for agentic CPUs — strong per-core performance under load, enough memory bandwidth per core, predictable latency (its 'chiplet tax' critique) — translates for SZL into a scheduling rule, not a hardware purchase: on the consumer-grade sovereign nodes, one long request must not head-of-line-block a concurrent run's loop steps, and shared-resource effects must be labeled (Alloy's energy windows are already declared WHOLE-GPU incl. concurrent load, never attributed solely to one run).

Applies to: sovereign-serving.

Evidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/


Honest boundary: every Vera number stays NVIDIA/partner-REPORTED — SZL owns no Vera silicon

88 Olympus cores, 50% IPC over Grace, 1.2TB/s LPDDR5X under 40W memory power, 3.4TB/s core-to-core on a monolithic die, 1.8x sustained per-core vs x86 — all NVIDIA-REPORTED. Perplexity 1.5x/1.9x, Starburst 3x, Redpanda 6x — partner-REPORTED, methodology unpublished here. None of these are SZL measurements and Alloy never presents them as facts about its own stack; the ONLY numbers Alloy adopts are the ones it measures on its own loop and metal. Rosa/Rigel is a REPORTED roadmap, not availability.

Applies to: honesty-doctrine.

Evidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/


Peak memory = one layer, not the sum — meta-device shell + forward hooks (code-verified)

AirLLM is a memory-management wrapper, not a re-implemented transformer: it builds the model as an empty shell on the meta device (init_empty_weights), then forward pre/post hooks stream each layer's weights disk→GPU right before it runs and evict them back to meta (module.to('meta') + clean_memory) right after. The VRAM ceiling becomes the largest streamed unit instead of the whole checkpoint. For szl-nemo on SZL's small-VRAM metal this is the second wall-breaking thesis alongside KTransformers' intensity-guided offload: the 'you need a datacenter card' wall is an assumption, not a law.

Applies to: szl-nemo.

Evidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/airllm_base.py


Per-layer safetensors shards with .done markers — the disk becomes the model store

split_and_save_layers pre-cuts a checkpoint into one safetensors shard per layer under splitted_model/, each guarded by a .done marker so interrupted splits resume idempotently instead of trusting half-written files. The cost is honest and stated in AirLLM's own FAQ: the split needs LARGE disk headroom. Any SZL layer-streaming recipe (forge, szl-nemo) inherits both halves — cheap idempotent resume via marker files, and a disk requirement that a VRAM-only fit check must never silently ignore.

Applies to: forge-training.

Evidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/utils.py


Prefetch overlap hides load latency — and is honestly disabled under compression

A single-worker ThreadPoolExecutor overlaps the NEXT layer's disk read with the CURRENT layer's compute — the overlap is the entire latency trick, and AirLLM turns it off when the 4/8-bit compression path is active (decompression changes the timing). Alloy's loop analogue applied 2026-07-12: the failover chain is strictly sequential (code-verified, Alloy does NOT prefetch), so every run's loop block now reports deadHopMs — the MEASURED-window sum of failed hops before the served one — as the DERIVED upper bound of wall that speculative warming could in principle hide (a counterfactual, never a realized saving; warming dead providers would also bill them).

Applies to: backbone-loop.

Evidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/airllm_base.py


Claims audit: 'Flash Attention' is not in the core path; 'no quantization' is default-only

Two popular-retelling claims fail the source audit: (1) the viral article credits Flash Attention, but the package's core inference path contains no AirLLM-authored flash-attn — it requests transformers' attn_implementation='sdpa' (fallback eager), so any kernel efficiency is inherited from PyTorch, and (2) 'runs without quantization' is true only of the DEFAULT: an opt-in compression='4bit'/'8bit' bitsandbytes block-wise quantization path exists whose own docstring concedes a small accuracy loss. Neither invalidates the core mechanism — but an honest retelling states both, which is why SZL's ingest notes carry them.

Applies to: honesty-doctrine.

Evidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/airllm_base.py


Every VRAM headline stays README-REPORTED — and the speed tradeoff is load-bearing

70B on a single 4GB card, ~1.6GB per layer, DeepSeek-V3 671B in ~12GB (which rides on the checkpoint's native FP8 weights, preserved verbatim) — all AirLLM-REPORTED figures that SZL never restates as its own measurements. The co-equal fact every retelling must carry: each generated token re-streams every layer from disk, so this is offline-batch tooling (document crunching, background analysis) — AirLLM's own framing is that it is not for live chatbots. A 'fits' verdict without the latency caveat would be a lie of omission.

Applies to: honesty-doctrine.

Evidence: https://raw.githubusercontent.com/lyogavin/airllm/main/README.md


The wall is a door — applied: the Layer-Fit Codex on the sovereign estate

The transferable thesis is the reframe itself: a hardware requirement is a sum-assumption that measurement can turn into a peak-assumption. Applied 2026-07-12: /api/estate/fit computes an AirLLM-style fit estimate for any public HF model against SZL's own nodes — REPORTED safetensors param totals + config.json geometry, DERIVED average-decoder-layer bytes (embed/lm_head excluded per tie_word_embeddings, KV-cache/activations excluded and stated, lower bound not a ceiling), compared against DECLARED owner-stated node VRAM (the szl-meters expose no memory gauge — MEASURED VRAM honestly does not exist today). The verdict is never a plain 'fits': disk headroom is UNKNOWN and the offline-batch caveat rides on every response.

Applies to: sovereign-serving.

Evidence: GET /api/estate/fit → perLayer.estBytes / nodes[].verdict


The thesis: the disclosure-to-exploitation window has collapsed to hours

The page's opening claim (Palantir-REPORTED) is that adversaries now use frontier and open-source models to reason through exploit chains and weaponize newly disclosed CVEs within hours, not weeks, so periodic scanners are structurally too slow. SZL neither confirms nor restates this as measured fact — but the reframe is the honest, checkable part: it is exactly what the public benchmark literature is now measuring (see the field-leaders takeaway), and it motivates why an always-on orchestrator loop beats a batch scan. Adopted as motivation, not as a Palantir statistic.

Applies to: frontier.

Evidence: https://www.palantir.com/security-forge/ (hero — "The Window Between Disclosure and Exploitation Has Collapsed")


Vulnerability operations = the whole discovery→remediation loop, humans in the lead at every critical decision

Security Forge's framing (REPORTED) is a shift from vulnerability SCANNING to vulnerability OPERATIONS: one connected loop of detect → validate → remediate → deploy/recall → learn, with a human owning every critical decision point rather than fully-autonomous action. This is the same shape as Alloy's own bounded agent loop, which is deliberately gated (owner-only decisions for archiving/licenses/training) and never claims autonomous authority. SZL's application is the discipline, not the product: a security loop must name where the human sits, and Alloy's loop trace already makes each hop and its authority explicit.

Applies to: backbone-loop.

Evidence: https://www.palantir.com/security-forge/ (Detect / Validate / Remediate / Deploy & Recall / Learn)


Ontology-grounded triage — the defender's context is the asymmetric advantage the attacker lacks

The page's strongest architectural idea (REPORTED): an adversarial model sees only the outside of a system, while a defensive model grounded in the org's own ontology sees pull requests, architecture decisions, ownership metadata, deployment history and service dependencies — so a finding can be triaged for REAL exploitability against full internal context, not scored in the abstract. SZL has no Palantir Ontology and claims none; the transferable principle is that context-of-ownership beats a raw severity number. Alloy's estate alignment cross-check and source registry are a much smaller instance of the same idea — internal context surfaced verbatim, never a fabricated link.

Applies to: frontier.

Evidence: https://www.palantir.com/security-forge/ ("Context and Control Your Adversaries Don't Have")


Model-family-agnostic pipelines — resilience must not be contingent on one provider's roadmap

Security Forge states (REPORTED) its review pipelines are not locked to a single model family, so as adversaries grow more capable the system adapts without depending on one vendor. This is precisely — and independently — Alloy's multi-provider failover thesis: Sovereign GPU → OpenAI → Moonshot → DeepSeek → Qwen → HF → OpenRouter → Gemini, chained so no single provider outage or capability gap breaks the backbone. The convergence is worth noting, but the principle is generic and was already load-bearing in Alloy before this study; nothing is borrowed, it is corroborated.

Applies to: sovereign-serving.

Evidence: https://www.palantir.com/security-forge/ ("resilience is never contingent on one provider's roadmap")


Compounding memory + full audit trail — the honest boundary on the customer numbers

Two more REPORTED ideas map onto SZL surfaces: 'compounding security memory' (every finding, false positive and fix feeds back so the next line of code is more secure) is the flywheel pattern, and 'every agent log, severity score and remediation step captured … full audit trail and complete chain of reasoning' is exactly what Alloy's ed25519-notarized, hash-chained receipt ledger already provides. The boundary held: the Accenture '700,000-person enterprise' and 'closes in a single automated loop' outcomes are Palantir/Accenture marketing claims — never SZL measurements, and SZL runs no AIP, Ontology or Apollo.

Applies to: honesty-doctrine.

Evidence: https://www.palantir.com/security-forge/ ("Compounding Security Memory"; "In Production at Accenture")


The orchestration layer is the durable investment — models are interchangeable

Lumbra's central conviction (REPORTED): 'Models are interchangeable. The orchestration layer is the durable investment.' The layer, not any one model, captures institutional knowledge, enforces evaluation at every junction and maintains provenance from intent to insight. This is the same bet Alloy makes: Alloy IS an orchestration backbone that treats each provider as a swappable target behind a stable routing/receipt/honesty contract. Convergent design, arrived at independently — corroboration that the durable value lives in the loop, not the weights.

Applies to: backbone-loop.

Evidence: https://lumbra.ai/technology ("Models are interchangeable. The orchestration layer is the durable investment.")


Eval-first: define what good looks like BEFORE deploy; validate in-line, not post-hoc — gap CLOSED 2026-07-12: graded rubric BUILT

Lumbra's first engineering principle (REPORTED): 'Evaluation is the first thing we build, the last thing we ship, and runs continuously in between' — every model integration starts with the rubric, not the prompt, and in-line validation aims to catch hallucination, drift and confidence-collapse before a human sees the output. Alloy's honest analogue was the self-verification second pass plus the live honesty audit — evaluation at the junction, not after the fact. The gap this study originally recorded (junction-check is honesty-LABELING, not yet a graded pass/fail rubric with a defined 'good' threshold) was CLOSED 2026-07-12: the SAME single bounded self-verify pass now also grades the output against a DECLARED fixed rubric (goal-addressed / internally-consistent / no-unsupported-claims, threshold 'PASS iff every criterion is PASS'), surfaced on the run result and in the Run Console. Honesty holds: every verdict is model-REPORTED self-grading by the same model class — never external ground truth, a PASS is never proof of correctness; an unparseable grade is verdict UNPARSEABLE (never coerced to a pass — live-verified: a 3B sovereign model returned UNPARSEABLE and it was shown as exactly that); the rubric attaches only to a real SELF-CHECKED pass, never to demo output, and the verify pass still never inflates the loop iteration count.

Applies to: honesty-doctrine.

Evidence: https://lumbra.ai/technology (Engineering Principles — "01 Eval-first") ; Alloy backbone.ts runSelfVerification() rubric + VerificationRubric schema + RunConsole rubric chips (live, built 2026-07-12)


Provenance: every conclusion has receipts — full lineage through every gate

Lumbra: 'Nothing in the system exists without lineage. Every output traces back through every reasoning step, every source, every evaluation gate it passed through. When the analyst asks why, the system shows its work.' (REPORTED.) This is, almost verbatim, the promise Alloy already ships: every /run carries an ed25519-signed receipt over sha256 hashes plus the full routing trail and servedNode, hash-chained in Postgres and re-verifiable in-browser via WebCrypto. SZL does not need to adopt anything here — it is the strongest external confirmation that receipt-backed provenance is the right spine. Noted as convergence, nothing copied.

Applies to: honesty-doctrine.

Evidence: https://lumbra.ai/technology (Engineering Principles — "02 Provenance / Every conclusion has receipts")


Knowledge capture as durable operational rubrics — SZL's honest, narrower instance

Lumbra markets capturing expert reasoning as 'living orchestration' so institutional knowledge outlives the expert — expertise encoded as operational rubrics, not tribal wisdom (REPORTED). SZL claims nothing about capturing human-expert reasoning; but the machine-checkable knowledge SZL DOES encode durably — the Lean proof ledger, the sympy formula ledger, and this very ingest codex — is a narrower, honest form of the same idea: knowledge that survives as re-runnable artifacts rather than lore. Applied as a framing for why the ledgers matter, with the scope difference stated plainly.

Applies to: frontier.

Evidence: https://lumbra.ai/mission ("An operating system that captures expert reasoning as living orchestration.")


Fashion thinking: Lumbra's visual language studied as INSPIRATION — Alloy stays itself

The owner likes Lumbra's front-end, so its design language was studied (not copied): a dark high-contrast canvas, a geometric-sans + monospace pairing, hard 0px corners over rounded cards, oversized editorial headlines, and — most relevant — receipts / pass-fail / 'the machines explain themselves or they don't ship' elevated to first-class UI motifs. The honest application is to lean INTO what Alloy already is: its receipt chain, honesty labels and pass/fail verdicts are exactly the 'show its work' aesthetic Lumbra sells, so the design lesson is to make those existing truth-surfaces more prominent — NOT to repaint Alloy in Lumbra's amber (#F5C94A) or ship its fonts/logo/copy. Alloy keeps its #3af4c8 identity; zero Lumbra assets are used.

Applies to: frontend.

Evidence: extractBranding(lumbra.ai) → dark scheme, Space Grotesk + Geist Mono, #F5C94A accent, 0px radius (studied, not adopted)


Honest boundary + the REAL field leaders: the checkable frontier is public, not marketing

Lumbra's 'production IC/DoD deployments' and the Bloomberg '$338B market' are Lumbra/press-REPORTED and unverifiable by SZL, so they are recorded as claims, never facts. The genuinely checkable frontier of agentic security — the publications and repos SZL actually tracks — is public and evidence-backed: arXiv benchmarks CVE-Bench (2503.17332, exploiting real web-app CVEs), SEC-bench (2506.11791, NeurIPS 2025), PatchEval (2511.11019) and ExploitBench (2605.14153) for autonomous detection→patch→exploit evaluation, plus open frameworks usestrix/strix, vxcontrol/pentagi and SEC-bench/SEC-bench on GitHub. These — not a marketing page — are the leaders a MEASURED/REPORTED surface may cite.

Applies to: frontier.

Evidence: arXiv 2503.17332 · 2506.11791 · 2511.11019 · 2605.14153 ; github.com/usestrix/strix · vxcontrol/pentagi · SEC-bench/SEC-bench


The value is (ρᴸ, Mₜ): a state is never worth more than the record that governs it

Seed IQ's premise (AIX-DECLARED, resting on the REAL no-cloning theorem) is that you cannot copy an unknown quantum state, so the useful object becomes the pair (ρᴸ, Mₜ) — the governed logical state plus the side memory recording how it is interpreted, restored and committed. SZL adopts the SHAPE of this idea, classically and by analogy only: a run's honest value is likewise a pair — its output PLUS the ed25519-signed receipt that records the routing trail, servedNode and commit position. A bare number with no governing record is, in both worlds, not a trustworthy value. This is the honesty doctrine re-stated in a quantum-information vocabulary; nothing here makes Alloy quantum.

Applies to: honesty-doctrine.

Evidence: Wootters & Zurek, Nature 299:802 (1982), DOI 10.1038/299802a0 ; AIX post (ρᴸ, Mₜ formulation)


Restoration, not copying — recompute the governed value, don't trust a cached copy

Seed IQ replaces amplitude-copying with teleportation-assisted RESTORATION of the governed logical value onto valid execution support, with the source lane preserved (AIX-DECLARED; the teleportation primitive is Bennett et al. 1993, real). The transferable discipline — again classical and by analogy — is exactly how Alloy already treats its receipt chain: /receipts/recent RECOMPUTES the sha256 chain per request and /receipts/checkpoint re-signs per request rather than serving a stored verdict, so trust is re-derived (restored) on read, never assumed from a copy. 'Restore the governed value, don't trust a copy' is a principle Alloy can honestly sharpen without any quantum machinery.

Applies to: backbone-loop.

Evidence: Bennett et al., PRL 70:1895 (1993), DOI 10.1103/PhysRevLett.70.1895 ; Alloy /receipts recompute-per-request


Dissipation as a restoring force — failure should damp toward the truth manifold, not leak

Seed IQ's most striking framing (AIX-DECLARED, on the REAL GKLS/Lindblad form ∂ρ/∂t = −i[H,ρ] + Σₖ(LₖρLₖ† − ½{Lₖ†Lₖ,ρ})) is that the Lₖ channels are not passive noise but SCHEDULED restore channels that damp leakage and redrive the register toward the committed logical value — dissipation becomes the correction, a real research line (Diehl 2008; Mirrahimi 2014). SZL keeps this strictly as a design METAPHOR, labelled as such: Alloy's honesty machinery already behaves like restore channels — a failed upstream damps to UNAVAILABLE instead of leaking a fabricated number, and the self-verification second pass pulls a run's reported shape back toward what was actually measured. The metaphor is useful; the claim that Alloy is an open quantum system is NOT made.

Applies to: honesty-doctrine.

Evidence: Lindblad, Commun.Math.Phys. 48:119 (1976), DOI 10.1007/BF01608499 ; Mirrahimi et al., arXiv:1312.2017 (2014)


Side memory Mₜ = a commit history with admissibility — Alloy already keeps one, classically

Seed IQ's Mₜ records syndrome, branch, frame, restore path, admissibility and commit history so the governed value can be interpreted and re-committed (AIX-DECLARED, grounded in real stabilizer/QEC theory: Gottesman 1997, Knill 2005). Alloy's hash-chained receipt ledger is a classical instance of exactly this bookkeeping: each row carries the prior hash (the chain/commit history), the routing trail (branch/restore path) and a recomputed chainStatus of VERIFIED / PARTIAL / BROKEN / EMPTY (admissibility). The lesson SZL takes is that admissibility must be a first-class, re-derivable field — which Alloy's chainStatus already is — not an afterthought; stated as convergence, nothing borrowed.

Applies to: honesty-doctrine.

Evidence: Gottesman 1997 (stabilizer codes); Knill 2005 ; Alloy receipt chain chainStatus VERIFIED/PARTIAL/BROKEN/EMPTY


Fashion thinking: take the 'governed value / restore / commit / admissibility' language as design inspiration

The owner asked to take the design thinking wholesale, so Seed IQ's conceptual VISUAL LANGUAGE is studied as inspiration only: a value shown as a governed pair, an explicit restore-path, a commit history, and an admissibility verdict rendered as first-class UI — the same 'the system shows how it holds its own truth' aesthetic Alloy already earns with its receipt chain, honesty labels and pass/fail verdicts. The honest application is to make those EXISTING truth-surfaces more prominent and to borrow the vocabulary (restore / governed value / admissibility) in copy where it clarifies — NOT to imply Alloy is quantum, and NOT to re-use any AIX asset, logo, colour or trademark treatment. Alloy keeps its #3af4c8 identity and its own components.

Applies to: frontend.

Evidence: AIX Seed IQ post (governed value + restore path + commit history + admissibility motif) — studied as inspiration, not adopted


The binding boundary: real physics, DECLARED synthesis, classical Alloy — three labels never blended

This entry exists BECAUSE the honesty doctrine forces the separation. The cited physics is REAL and checkable (DOIs above). The Seed IQ™ runtime that fuses it into governed teleportation-assisted memory — plus AIX's broader claims (a domain-agnostic adaptive multiagent control layer, Active Inference, the patented ΑΩ FoB HMC / Alpha-Omega Field of Belief with Hamiltonian Monte Carlo engine, quantum + data-center deployments) — is AIX-DECLARED: SZL has audited no code, reproduced no result, and measured nothing, so none of it is ever restated as SZL fact. And Alloy itself remains a classical software orchestrator with zero quantum hardware. Every takeaway above is analogy or inspiration held on the SZL side of that line — the ideas sharpen how Alloy talks about and renders its OWN provenance, and change none of its actual mechanism.

Applies to: honesty-doctrine.

Evidence: https://aix.us.com ; zenodo.org/records/20585365 (AIX-authored, unaudited by SZL)


Meta-harness / provider-agnostic orchestration — CONVERGENCE with Alloy's router, not adoption

Omnigent's core is a meta-harness: one orchestration layer that swaps or combines whole agent runtimes (Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, custom YAML agents) without rewriting the caller. Alloy already operates the same shape one level down — a provider router (registry.ts) that puts Sovereign GPU nodes, OpenAI, Moonshot, DeepSeek, Qwen, Hugging Face, OpenRouter and Gemini behind one interface with a single failover chain (the sovereign tower→laptop failover and OpenRouter serving are MEASURED live; the key-dependent cloud providers are configured targets, not each independently re-verified here). So this corroborates a decision Alloy already made and runs; it is CONVERGENCE, not something to newly 'adopt'. The honest delta Omnigent points at is generalizing the unit from a model/provider to an entire agent harness — a DECLARED future direction for Alloy, not a claim it exists today.

Applies to: backbone-loop.

Evidence: Omnigent README (meta-harness over Claude Code/Codex/Cursor/OpenCode/Hermes/Pi) ; Alloy registry.ts providerToTargets() failover chain (live)


A first-class policy engine (approval gates, spend caps, tool allow-lists) — gap FULLY CLOSED 2026-07-12: spend cap + provider allow-list + per-action approval gates all BUILT

Omnigent lets you write policies that pause for human approval before risky actions, cap spend, or restrict which tools an agent can reach, scoped to the whole server, one agent, or a single chat. This study originally recorded the whole cluster as a DECLARED gap. As of 2026-07-12 Alloy has BUILT all three enforceable pieces for real: (1) an enforced rolling-24h spend cap (env A11OY_SPEND_CAP_USD_DAY, enforced over the MEASURED ledger tally of per-run ESTIMATED amounts — a sum of estimates, never billing truth; ledger-down = enforcement honestly SUSPENDED, unset = honestly OPEN); (2) a provider allow-list (env A11OY_PROVIDER_ALLOWLIST, filtering the ENTIRE failover chain, not just the requested head); and (3) per-action human-approval gates (env A11OY_APPROVAL_MODE=required): every /run and /run/stream call must spend a single-use, short-TTL approval ticket minted by the run-key holder via POST /policy/approvals — one mint is one explicit human approval for one action; unset = honestly OPEN (stated, never silently waved through), required-without-a-run-key = honestly MISCONFIGURED (tickets unmintable, runs refused with that exact reason). All three gate BEFORE any provider call; denied requests are never ledger rows (nothing ran). E2E-verified live 2026-07-12: 403 without ticket, 401 on wrong mint key, mint → run → same ticket refused as spent, MISCONFIGURED refusals verbatim.

Applies to: backbone-loop.

Evidence: Omnigent README §'Govern your agents with policies' ; Alloy policy.ts gateRun()/evaluatePolicy() + approvals.ts single-use ticket store + POST /policy/approvals + runLedger.ts getSpendWindow() + GET /policy (live; caps/allow-list built 2026-07-12, approval gates built + E2E-verified 2026-07-12)


Governed-execution + accountability as first-class — CONVERGENCE with Alloy's receipts

Omnigent treats governance and supervision of agents (watch live, pause, review one agent's work with another) as a primary product surface, not an afterthought. Alloy independently reached the adjacent conviction that a run must be ACCOUNTABLE: every run is notarized with an ed25519-signed, hash-chained receipt whose chain is recomputed and re-verified per request, with client-side WebCrypto verification. Both designs say 'the machine must be able to prove what it did'. This is recorded as convergence — Alloy's receipt chain predates and is unchanged by the study — not as an Omnigent feature imported.

Applies to: honesty-doctrine.

Evidence: Omnigent README (supervise/govern/collaborate) ; Alloy receipts.ts ed25519 chain + ReceiptChain.tsx client verify (live)


OS + cloud sandboxing for agent isolation — studied, LIMITED applicability to Alloy

Omnigent wraps each agent terminal in an OS sandbox (Linux bwrap, macOS seatbelt) with an L7 egress proxy, and can run sessions in disposable cloud sandboxes (Modal, Daytona, E2B, CoreWeave, Kubernetes, Databricks, etc.). This is essential for Omnigent because it executes arbitrary agent-authored code. Alloy's threat surface is narrower — it orchestrates bounded model/inference calls, not arbitrary shell — so full OS-sandboxing is only partially applicable. The honest, transferable lesson is the L7 egress-governance idea for any future tool-execution path Alloy adds; recorded as studied with its scope limit stated, not as a capability Alloy needs or has.

Applies to: sovereign-serving.

Evidence: Omnigent README (bwrap/seatbelt, L7 egress proxy, Modal/Daytona/E2B/CoreWeave/K8s/Databricks sandboxes)


Honest boundary: alpha status, REPORTED adoption, zero code borrowed

Omnigent is Apache-2.0 and self-describes as ALPHA. Its capability and adoption claims (device-portable sessions, multi-harness supervision, managed hosts) are Omnigent-REPORTED; SZL has verified none of them by running the software. The one live figure in this row is its GitHub metadata (stars, last-push, license SPDX) fetched by the ingest route's REPORTED fan-out — GitHub's own numbers passed through and labelled REPORTED (never MEASURED, which is reserved for Alloy's own measurements), honestly UNAVAILABLE if the fetch fails, never invented. Alloy remains its own TypeScript codebase with its own #3af4c8 identity; no Omnigent code, logo, colour or asset is re-used, and every convergence above is corroboration of Alloy's existing design, not adoption of Omnigent's.

Applies to: honesty-doctrine.

Evidence: github.com/omnigent-ai/omnigent (Apache-2.0, status alpha) — live REPORTED meta in this row's GitHub block


Latent-space verification, operationalized: hash/signature-space coverage on the Ouroboros invariants panel

The JEPA family's defining move is to work in a compact DERIVED space rather than the raw object — Neuro-JEPA predicts the latent representations of masked regions from visible context (never voxel reconstruction). Alloy's honest ANALOGY is that it already establishes trust in a derived space too: every run is notarized with an ed25519 signature over sha256 canonical bytes — the plaintext is NEVER in the receipt. This study made that analogy OPERATIONAL: GET /invariants now emits a MEASURED latentVerification coverage ratio (verified / enumerated ledger rows verifiable purely in hash+signature space), with honest complements rotated (signed under a rotated key) and unsigned (rows predating signing) and a falsifiable tamperFailed count, rendered on the OuroborosInvariants panel. CRITICAL label boundary: Alloy's 'latent space' is a CRYPTOGRAPHIC DIGEST + SIGNATURE, NOT a learned embedding — nothing here is trained, predicted, or a model, and it does not prove or upgrade Λ (Conjecture-1). It is a coverage metric, deliberately NOT a HOLDS/VIOLATED invariant, so it does not pretend to be a falsifiable predicate it is not.

Applies to: honesty-doctrine.

Evidence: arXiv:2606.14957 §Methods (JEPA latent-predictive objective, EMA target encoder) ; Alloy invariants.ts latentVerification block + OuroborosInvariants.tsx (live MEASURED coverage)


Non-generative, recompute-on-read stance — CONVERGENCE with Alloy's receipts, not adoption

Neuro-JEPA is deliberately NON-GENERATIVE: it learns by predicting representations, and the paper reports (paper-REPORTED) it beats reconstruction-based MAE under equivalent settings. Alloy independently reached an adjacent conviction — it does not cache or fabricate a stored verdict; the receipt chain and every invariant are RECOMPUTED per request over the enumerated tail, and chainStatus is re-derived, never served from a frozen 'proof'. Both designs prefer deriving-on-demand over storing-a-generated-artifact. Recorded as CONVERGENCE: Alloy's recompute-per-request receipt chain predates and is unchanged by this study.

Applies to: backbone-loop.

Evidence: arXiv:2606.14957 §Methods (latent prediction chosen over MAE reconstruction, paper-REPORTED) ; Alloy receipts.ts + invariants.ts (recomputed per request)


Sparse Mixture-of-Experts routing — ANALOGY to the provider router + failover chain

Neuro-JEPA's backbone routes each token through a sparse MoE (paper-REPORTED: 2 shared + 16 experts, 6 activated per pass, on alternating layers, with auxiliary-loss-free bias-update load balancing to stop collapse onto a few experts). This is thematically ANALOGOUS to Alloy's orchestrator dispatching each run to a subset of specialist providers (Sovereign GPU nodes, OpenAI, Moonshot, DeepSeek, Qwen, Hugging Face, OpenRouter, Gemini) with a failover chain that spreads load and avoids single-provider collapse. ANALOGY ONLY — Alloy shares no MoE implementation, no gating network, and no learned routing; its routing is declared-config + failover, not a trained router.

Applies to: backbone-loop.

Evidence: arXiv:2606.14957 §Methods (MoE 2 shared + 16 experts, 6 active, bias-update load balancing, paper-REPORTED) ; Alloy registry.ts providerToTargets() failover


DECLARED gaps: representation training and world-model planning — Alloy trains NO models

Neuro-JEPA is a trained foundation model with an online encoder + momentum (EMA) target encoder, pretrained on 1,551,862 scans (paper-REPORTED). Alloy trains NOTHING — it orchestrates bounded calls to already-trained providers and its sovereign flywheel only COLLECTS its own verified own-metal serves as future training samples; it runs no pretraining, no EMA target, no representation-learning objective. So representation learning and JEPA-style world-model/planning are honestly-named DECLARED gaps, not capabilities Alloy has. It would be dishonest to imply Alloy learns latents; it does not, and this takeaway says so.

Applies to: forge-training.

Evidence: arXiv:2606.14957 §Pretraining (online + EMA target encoders, 1.55M scans, paper-REPORTED) ; Alloy has no training loop — flywheel.ts only counts verified own-metal serves


Honest boundary: split license, paper-REPORTED metrics, zero weights/assets borrowed

The code is MIT (reusable with attribution + review of upstream V-JEPA 2 terms) but the WEIGHTS are CC-BY-NC-ND-4.0 — non-commercial, no-derivatives, non-clinical, gated (the HF README returns 401 without institutional-email approval), so they cannot be adopted, redistributed, or built upon; GitHub reports SPDX NOASSERTION precisely because of this split. Every performance figure (average AUROC/AUPRC gains, few-shot deltas, brain-age R²/MAE) is the authors' paper-REPORTED claim and is never restated as an SZL measurement. No weights were downloaded, no figures/GIFs from their assets/ folder are re-used, and Alloy keeps its own #3af4c8 identity and TypeScript codebase. The arXiv id 2606.14957 and its 2026 dates are recorded verbatim as published, not corrected.

Applies to: honesty-doctrine.

Evidence: github.com/NYUMedML/Neuro-JEPA LICENSE (MIT code) ; huggingface.co/NYUMedML/Neuro-JEPA (weights cc-by-nc-nd-4.0, gated:manual, card 401) ; arXiv:2606.14957 (CC BY 4.0 paper)


The substrate taxonomy, applied only as far as honesty reaches: the fleet substrate ledger

The piece's usable kernel is a vocabulary: modern serving runs on distinct silicon classes (CPU/GPU/LPU/NPU). Alloy now applies that taxonomy to its OWN fleet exactly as far as evidence exists — every provider on GET /backbone/status carries a substrate field with a verbatim basis. Own metal is the ONLY substrate Alloy can claim: 'GPU', labelled DERIVED, because the szl-meter exporters sample NVML energy counters on the serving nodes and NVML exists only on NVIDIA GPUs (class evidence from MEASURED samples — never a die/SKU claim). Every cloud provider is honestly UNKNOWN: serving silicon is unobservable through an OpenAI-compatible API, so it is never guessed — Google's TPU marketing stays Google-REPORTED, OpenRouter's per-request vendor roulette is doubly unobservable, and the ProviderFleet panel renders the ledger with the basis on hover.

Applies to: backbone-loop.

Evidence: Alloy registry.ts providers[] substrate/substrateLabel/substrateBasis + ProviderFleet.tsx substrate row (live) ; szl-meter NVML sampling (energy.ts, MEASURED)


The 'ecosystem of specialists' conclusion — CONVERGENCE with the router, one layer up

The piece concludes the future is 'an ecosystem where specialized, AI-native processors handle what they do best' rather than one chip to rule them all. Alloy independently embodies the same shape one layer UP the stack: a multi-provider router that dispatches each run across a heterogeneous fleet (own GPU metal first, then seven cloud vendors) with a failover chain, letting each configured provider serve what it serves best. Recorded as CONVERGENCE at the orchestration layer, not adoption — Alloy's router predates this paste and orchestrates PROVIDERS, not silicon; it schedules nothing onto a CPU/GPU/LPU/NPU itself.

Applies to: backbone-loop.

Evidence: Alloy registry.ts providerToTargets() failover chain (live, predates this study) ; paste §'The Big Shift: Specialized Computing'


LPU and NPU: honestly absent from the fleet

No Groq-style LPU and no on-device NPU serves an Alloy run, and none is claimed — the ProviderFleet caption states this outright. The piece's LPU performance framing ('ChatGPT-like speeds instantly', 'drastically reducing latency and maximizing token throughput') cites no benchmark and is the author's restatement of vendor-adjacent marketing — author-REPORTED, never an SZL measurement. If a cloud vendor behind one of Alloy's providers happens to serve on an LPU or ASIC, Alloy cannot see it, so its substrate stays UNKNOWN rather than becoming a borrowed marketing claim.

Applies to: sovereign-serving.

Evidence: ProviderFleet.tsx caption (no LPU/NPU claimed) ; paste §3 (LPU claims, no benchmark cited)


Honest boundary: an unattributed paste is a viewpoint, not a source

This entry exists partly to record HOW unattributed content is ingested under the honesty doctrine: authorship, publication, and license are UNKNOWN and stated verbatim; the checkable kernel (the four silicon classes exist as real product categories) is separated from the editorial framing (the analogies, the evolution arrow, the 'officially dead' and 'burning your budget' claims — the latter unfalsifiable as stated); no claim is upgraded by ingestion. The entry renders with no source link because none exists — a deliberate honest non-link, never a fabricated href. Nothing in this study changes any Alloy mechanism; it adds vocabulary and one new honest surface (the substrate ledger).

Applies to: honesty-doctrine.


The reframe: work-memory (what the AGENT did) is a distinct, more useful axis than user-profile memory

Brain's central thesis (REPORTED): AI memory has two axes — what it is ABOUT and what it is FOR. Traditional memory is about the user (preferences/contacts) and for engagement; Brain remembers what the AGENT did — what worked, what failed, what corrections were made — and is FOR getting better at the job. This is the load-bearing, checkable idea. For SZL it is CONVERGENCE, not adoption: Alloy's run ledger already records every run's route, outcome, and failure — it is a work-memory store by construction, with no user-profile memory anywhere. Brain names the axis Alloy was already on.

Applies to: backbone-loop.

Evidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents ("Brain remembers what the agent did … the most important purpose of memory")


Provenance on every memory entry — Alloy's receipts are the stronger form (CONVERGENCE)

Brain (REPORTED) 'shows its work': every memory entry links back to the session, file, or source it came from. This is exactly Alloy's receipt spine — but Alloy's is cryptographically stronger: every /run carries an ed25519 signature over sha256 hashes, hash-chained in Postgres and re-verifiable in-browser via WebCrypto, not just a hyperlink. SZL adopts nothing here; it is the strongest external confirmation that provenance-per-entry is the right design. Noted as convergence, nothing copied.

Applies to: honesty-doctrine.

Evidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents ("Every memory entry links back to the session, file, or source that it came from")


Overnight synthesis pass into an auto-loaded LLM wiki — this is the GENUINE GAP for SZL

Brain (REPORTED) builds a context graph that takes the form of an 'LLM wiki automatically loaded onto the agent sandbox', 'incrementally updated overnight as it synthesizes the user's sessions, connector results, source changes, and corrections'. SZL already has the wiki artifact (.agents/memory/*.md, hand-maintained) — what is genuinely NEW and worth building is the SCHEDULED SYNTHESIS PASS that reads the run ledger and proposes distilled notes. The open-source field proves it is buildable (A-MEM note-evolution, Generative-Agents reflection, OpenAI 'Dreaming'); Brain is the productized packaging. SZL's version must stay honest: a synthesis pass PROPOSES, provenance-linked, never silently overwrites, and claims no % gain it did not measure.

Applies to: backbone-loop.

Evidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents ("an LLM wiki that's automatically loaded … incrementally updated by the Brain system overnight")


Learn from mistakes and corrections → fewer turns — maps to Alloy's failure ledger + self-verify

Brain (REPORTED): agents 'learn from their mistakes, remembering when a user made a correction or when a source was a dead end … fewer turns, fewer model calls, better outputs.' Alloy already stores every FAILURE in the ledger (not just successes) and runs a graded self-verification pass (PASS/UNPARSEABLE, model-REPORTED self-grading, never external ground truth). The GAP: Alloy does not yet turn a failed/low-grade run into a written, retrievable 'lesson' that conditions the next similar attempt (the Reflexion pattern). Adopting this stays honest only if the lesson is labeled model-generated CONJECTURE, provenance-linked to the failing run, never a claimed fact.

Applies to: backbone-loop.

Evidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents ("They also learn from their mistakes … fewer turns, fewer model calls")


Honest boundary: every Brain number stays Perplexity-REPORTED, scoped, and unaudited

The three headline figures are Perplexity's own 'early measurement results', with their scoping caveats that MUST ride with them: +25% correctness applies only to 'tasks Computer has seen before', −13% cost only to 'tasks that require historical context', +16% recall unscoped. No methodology, task set, sample size, or baseline is published; Brain is a closed product SZL cannot inspect. SZL restates none of these as its own results and seeds no Alloy headline with them. The ONLY numbers Alloy ever adopts are the ones it measures on its own loop and metal. 'Recursive self-improvement' and 'proactive AI that flags problems before anyone notices' are aspirational marketing, recorded as claims, never facts.

Applies to: honesty-doctrine.

Evidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents ("Early measurement results show … increases answer correctness by 25% on tasks Computer has seen before")


Bi-temporal memory: never overwrite a fact — invalidate it with a valid-time window + provenance

Graphiti's load-bearing idea (code + paper): every edge/fact carries BOTH event time and ingestion time, and when a fact changes it is not deleted but INVALIDATED (valid-from / valid-to set), so the graph answers 'what did we believe, and when' while keeping a provenance link to the source. This is the field's strongest provenance-preserving memory design and a structural cousin of Alloy's append-only, hash-chained receipt ledger (CONVERGENCE — Alloy never overwrites a run either). The transferable PATTERN for a future SZL memory-synthesis pass: correcting a memory adds an invalidation with valid-time, never a silent overwrite — honesty-preserving by construction.

Applies to: honesty-doctrine.

Evidence: https://github.com/getzep/graphiti ; https://arxiv.org/abs/2501.13956


Incremental, hybrid retrieval over a temporal graph — no batch recompute

Graphiti updates the graph incrementally per episode (no full re-embedding) and retrieves via hybrid semantic + keyword (BM25) + graph traversal, purpose-built for evolving real-world data rather than a static document store. For SZL this is an ANALOGY, not an adoption: Alloy's ledger is time-ordered Postgres, and any future memory-retrieval lane should combine relevance with recency rather than pure vector similarity — but SZL would build its own honest, MEASURED implementation, not vendor a graph DB it cannot operate on its two-node fleet.

Applies to: backbone-loop.

Evidence: https://neo4j.com/blog/developer/graphiti-knowledge-graph-memory/


Consolidation write-path: extract salient facts, then decide add/update/merge/delete/noop — not append-only

Mem0's load-bearing mechanism: rather than appending raw turns, an LLM extracts salient facts and RECONCILES them against existing memory with an explicit add / update / delete / noop decision, so contradictions are resolved instead of accumulated. This is the exact shape a future SZL overnight synthesis pass needs over the run ledger — BUT SZL's honesty doctrine forbids the silent 'delete/overwrite' branch: SZL's reconciliation must PROPOSE changes with provenance to the runs that motivated them (Zep-style invalidation), never silently rewrite history. Adopted as a PATTERN with a doctrine guardrail, not as code.

Applies to: backbone-loop.

Evidence: https://github.com/mem0ai/mem0 ; https://arxiv.org/abs/2504.19413


Memory as a standalone service any framework calls — plus an honesty boundary on the benchmark numbers

Mem0 packages memory as a provider-agnostic layer (vector + optional graph store, Mem0ᵍ variant) callable from any agent framework — a clean separation-of-concerns worth mirroring in how SZL would expose a memory lane behind a stable contract (as Alloy already does for providers/receipts). The boundary that must ride with it: Mem0's '+26% accuracy / −91% tokens vs full-context' style figures are self-REPORTED on their own LOCOMO setup and have been publicly contested; SZL cites them as Mem0's claim, never as evidence about SZL's own stack.

Applies to: honesty-doctrine.

Evidence: https://mem0.ai/ (self-reported benchmarks) ; https://docs.mem0.ai/platform/overview


LLM-as-OS: tiered context with agent-managed paging under an explicit token budget

MemGPT's durable idea: treat the LLM like a process on a memory-constrained OS — a small in-prompt MAIN context plus large EXTERNAL (recall/archival) storage, with the agent issuing self-directed calls to page memory in/out and edit its own 'memory blocks'. The transferable PATTERN for SZL: context assembly is a budget-managed decision, and a distinct editable 'working-memory block' (agent-maintained) can sit alongside the immutable archival run ledger. ANALOGY only — Alloy's context is currently assembled deterministically per run; self-editing memory would be a new, opt-in, provenance-labeled lane, never silent state.

Applies to: backbone-loop.

Evidence: https://github.com/letta-ai/letta ; https://www.letta.com/blog/letta-v1-agent


Procedural / self-editing memory is the interesting part — and the honesty risk to manage

Letta markets 'agents that learn and self-improve over time'; the honest reading is that the 'learning' is memory-EDITING (blocks the agent rewrites), not weight training — a distinction SZL must preserve so no panel implies on-the-fly model improvement. Combined with LangMem's semantic/episodic/PROCEDURAL taxonomy, the genuinely new lane for SZL is procedural memory (learned routing/recipe rules distilled from the ledger). Every such rule stays a model-generated CONJECTURE with provenance to the runs that produced it, subject to owner review before it can influence a live route.

Applies to: honesty-doctrine.

Evidence: https://github.com/letta-ai/letta (self-editing memory blocks / stateful agent server)


The Decay Ledger node model — a finding decays hop-by-hop, and no node is accountable

Ferguson traces one fact through five nodes (paper → university press office → wire → aggregator → Vice) and shows each hop adds confabulation: the press office "reframes a framework paper as a body of findings" by retrieving true-but-adjacent material ("All of it real. None of it in the source document"), the wire "performed a disclaimer", the aggregator faithfully summarizes a corrupted source, and the final outlet invents "participants who do not exist." His hinge (verbatim): "There are no lonely people in that paper. There are no participants in that paper. There is no experiment in that paper." SZL's /api/decay antiDecayMap borrows the HOP framing as a labeled ANALOGY only — his diagnosis stays cited to him, and our map claims only what each of our own hops mechanically enforces.

Applies to: honesty-doctrine.

Evidence: .local/ingest-lab/wave11/ferguson-decay-ledger-article.md (saved verbatim, fetched 2026-07-12)


The missing "cosigner" — a consequence-bearing component that can refuse

His core diagnosis (verbatim): "Every actor in this chain made a locally reasonable decision. The aggregate output is a fabrication… That is what a system with no consequence-bearing component does, and it will do it every single time, at whatever speed you run it." And: "accountability is not a policy layer bolted onto a system. It is endogenous to the decision." He names the missing part the "cosigner" — "the only component in the entire architecture that can refuse, and the only one who eats the consequence when he refuses wrongly." For SZL this seeds the Decay Ledger organ's design question: which of OUR hops can actually refuse (Zod reject, sovereign-only gate, UNSIGNED receipt state, honest UNAVAILABLE) — and each refusal path is listed with its falsifiable check, never asserted abstractly.

Applies to: honesty-doctrine.

Evidence: .local/ingest-lab/wave11/ferguson-decay-ledger-article.md (§1e verbatim quotes)


Reward-function argument: "Every node… was rewarded for amplification. No node was penalized for decay."

Ferguson's structural claim (verbatim): "That is not journalism failing. That is a reward function working exactly as designed" — and "We did not build machines that hallucinate like institutions. We built institutions that hallucinate, wrote it all down, and then used it as training data." His remedy is the alignment-breaker: "somebody stops nodding along and says wait, that is not what it says" — the slow, expensive editor who is "the first line item cut." These stay HIS claims. The transferable discipline for SZL: abstention and refusal must be first-class, non-penalized outputs (UNAVAILABLE over invented numbers, INSUFFICIENT over fabricated agreement) — which Alloy already enforces by doctrine, so the essay is convergent confirmation, not a new adoption.

Applies to: honesty-doctrine.

Evidence: .local/ingest-lab/wave11/ferguson-decay-ledger-article.md (§1d, §1f verbatim quotes)


The primary numbers, kept primary: 4,046 fabricated citations / 2,810 papers / 97.1M references verified

As the authors state them (Columbia/EurekAlert release credited "Topaz et al., 2026, The Lancet"): ~2.5M PMC Open Access papers (2023-01-01 → 2026-02-18) scanned, 97.1 million references verified, 4,046 fabricated citations (resolve to no record in PubMed, Crossref, OpenAlex, or Google Scholar) across 2,810 papers; rate >12-fold up since 2023 (1-in-2,828 → 1-in-458 → 1-in-277 by early 2026); one paper had "18 out of 30" fake references (Topaz verbatim). The separate Nature+Grounded AI estimate (>110,000 pubs from 2025 with ≥1 invalid ref) is a DIFFERENT method on a DIFFERENT corpus and is never merged with the Lancet count. The undercount caveat (PMC-OA-only, PMID-resolvable-only) is commentators' interpretive claim, labeled as such.

Applies to: honesty-doctrine.

Evidence: EurekAlert #1127364 (Columbia release, primary-credited) ; https://pmc.ncbi.nlm.nih.gov/articles/PMC13051339/


Decay demonstrated on the decay literature itself: Retraction Watch printed 4,406 for 4,046

Retraction Watch (2026-05-07) restated the audit's rates correctly but printed the fabricated-citation count as "4,406" where the primary release and every other secondary source print "4,046" — two digits transposed in one press hop, while the paper count (2,810) and reference count (97.1M) survived intact. This is Ferguson's thesis in miniature, caught live in wave-11's own evidence base, and it is exactly why /api/decay tags every number with a sourceKind (PRIMARY/ESSAY/PRESS) and a numbersStatus: a Decay Ledger that cannot distinguish the primary figure from the press transposition would itself be a decay node. Recorded as a discrepancy, not resolved by fiat.

Applies to: honesty-doctrine.

Evidence: https://retractionwatch.com/2026/05/07/one-in-277-pubmed-indexed-papers-in-2026-shows-fabricated-references-says-analysis/ (prints 4,406; primary release prints 4,046)


Citations-as-data (Resnik & Hosseini): if citations function as data they need data-integrity provenance

Resnik & Hosseini argue (their conditional, verbatim shape preserved) that hallucinated citations MAY constitute research misconduct when three conditions hold: GenAI produced the nonexistent citations, the citations FUNCTION AS DATA supporting findings, and the researcher showed indifference to fabrication risk. PLOS's counterpoint (via Retraction Watch: intent is decided institutionally) is recorded as live tension, and RW's ">98% of flagged papers saw no publisher action" stays RW's analysis. The transferable pattern for SZL: mechanical resolution-at-ingest (Topaz et al.'s four-database check; "publishers verify references with each paper submission") — a citation that does not resolve is flagged or rejected, never silently carried.

Applies to: honesty-doctrine.

Evidence: https://pmc.ncbi.nlm.nih.gov/articles/PMC13051339/ (CC BY 4.0 full text)


Semantic entropy = sample k → cluster by bidirectional NLI entailment → entropy over clusters

Their method detects confabulations by sampling several completions, clustering them into semantic-equivalence classes via bidirectional entailment (A entails B AND B entails A, judged by an NLI model such as DeBERTa-Large-MNLI or an LLM judge), then computing entropy over the cluster distribution — scoring MEANING, not surface form. Full SE needs white-box token probabilities; Discrete SE uses empirical cluster frequency and works black-box. Clustering costs O(M²) NLI forward passes. The structure (sample → cluster → entropy) is the intellectual parent of SZL's consistency probe.

Applies to: honesty-doctrine.

Evidence: https://doi.org/10.1038/s41586-024-07421-0 ; https://github.com/jlko/semantic_uncertainty