Publications

Five structurally distinct LLM families were each hand-ported into one custom Apple-GPU decode engine and profiled until each broke under single-stream 4-bit decode on a single M1 Ultra; only one satisfied all five rules. The result is a spec of five rules for fast single-stream decode on unified-memory Apple Silicon: low active params per token, vector-load-aligned quantization, experts big enough to fill the GPU at batch one, uniform attention, and a fusion-friendly non-hybrid layout. Meta-finding: architecture identity does not predict runtime cost; the rules are necessary, not sufficient.

Published 2026-06-15 · Version 3

A read-only static deep-dive falsifying that Gemma4-26B-A4B is structurally isomorphic to a mature Qwen3-30B-A3B MoE single-stream inference path on Apple Silicon, able to drop in and inherit its throughput. Ground-truth bf16 shapes break it on four axes: a stacked fused-expert layout, a dense-MLP plus routed-MoE hybrid, GeGLU not SwiGLU gating, and a heterogeneous sliding/full attention geometry with novel scalars. Verdict: NO-GO for a config-swap; only the MoE router carries over. A purpose-built port has a conditional throughput ceiling as a range. Nothing was run; figures are estimates.

Published 2026-06-15 · Version 3

Falsify-first root cause for a fatal trap that killed a single-resident 4-bit ~30B sparse-MoE decode daemon under concurrent decode on one Apple Silicon machine. An orchestration-free reproducer isolates the trigger: concurrent chat and interleaved chat-plus-embed crash, while embeddings-only and sequential traffic survive, refuting an "embeddings poison decode" guess. The mechanism is a batch-composition-change wipe of resident KV pools tripping a re-seed precondition no steady-state decode meets. Serializing GPU decode prevents it but gives no speedup; the per-stream fix is unimplemented.

Published 2026-06-15 · Version 3

A captured end-to-end run drives a governed ReAct agent over an authenticated HTTP route against a real, locally hosted quantized model. Four behaviors: a benign read-only calculator tool the model emitted ran and was audited; an injected unauthorized side-effect was denied by the governor before its handler fired; an unauthenticated request returned 401 and the agent never ran; memory was tenant-isolated across requests. It also corrects a prior false-by-default governance claim, making enforcement fail-closed by construction. Single manual run, not CI; no throughput or statistical claim.

Published 2026-06-15 · Version 3

Compatibility assessment of the DiffusionGemma-26B-A4B-it Q4_K_M GGUF (a block-diffusion MoE: non-causal, fixed canvas, self-conditioning) against a multi-backend inference engine on Apple Silicon (M1 Ultra, Metal). On-box header parsing identifies a ~25B-total / ~3.8B-active model. Verdict: NEEDS_ARCH_SUPPORT — the engine cannot load the GGUF and upstream llama.cpp rejects the architecture. An external self-built llama.cpp Metal baseline (not the engine under test) hits ~14-22 tok/s single-stream at q4. Public marketing throughput is apples-to-oranges vs single-stream Metal; one is refuted.

Published 2026-06-15 · Version 3

An honest decode-quality study of a self-hosted diffusion-style decoder versus a golden-only open-source reference on a 26-prompt set. Initial answer-hit was 7/26 versus reference 25/26, most failures stuck in the thought trace, never reaching the answer channel. The central finding is an experimental self-correction: a controlled A/B and isolation matrix refute the prior decode-policy attribution. The binding variable is canvas geometry plus chat template; argmax-vs-multinomial is neutral. A template fix and a faithful multinomial denoiser lift answer-hit to 23/26, short of reference-aligned.

Published 2026-06-15 · Version 3

Continuity can rest on one primitive: a durable, append-only, hash-chained session log of visible token emissions, not KV-cache. We show deterministic cold replay with exactly-once visible emission, tamper detection via chain breaks, cross-machine replication surviving disk loss and a full coordinator-process kill, and operator-allowlisted self-healing recovery. Rebuild refuses model, sampler, or backend mismatch. Cross-chip KV-cache replication is a decisive negative: post-encoding float state is not bit-portable. Evidence is mock and small-open-model scale on a LAN; single runs.

Published 2026-06-15 · Version 3

Sovereign M1 Ultra forward port of gpt-oss-20B in native MXFP4, no vendor BLAS. The MXFP4 reader is bit-exact and the full 24-layer forward is verified correct against a Hugging Face golden (min final-logits cosine 0.9969, argmax matches); learned attention sinks are load-bearing. Single-stream decode improved via command-buffer fusion and a cooperative-GEMV lever but topped out near 14.6 tok/s, below the pre-registered 18 tok/s threshold: fine-grained-MoE experts are too small to fill the GPU (~7% bandwidth). The 120B inherits the same ceiling, so it was not ported. Honest negative result.

Published 2026-06-15 · Version 2

A per-stream KV-slot isolation refactor for an Apple-Silicon 4-bit MoE decode path fixes a concurrent-decode crash and enables true-parallel ragged decode. A stable per-stream slot indexes the batched KV arena instead of wiping it per batch change; the legacy single-stream path stays byte-for-byte intact. On a real 4-bit 30B-class MoE: solo greedy output is byte-identical to baseline; six concurrent ragged streams that crashed the prior path now survive byte-identical and deterministic; single-stream throughput equals baseline. A follow-up closes a single-vs-batched FP divergence. Single run.

Published 2026-06-15 · Version 4

On a text-diffusion Gemma MoE (26B-A4B-class, 128 experts, top-8 routing) forward on a 20-core-class Apple Silicon machine, the per-(token,expert) expert FFN — where each tiny M=1 GEMV spawned its own narrow parallel launch, starving the cores — was restructured into one flat parallel pass per layer over a job list of F16-resident experts. On one short-canvas, 4-step decode run, decode wall fell ~1.6x with higher CPU utilization, while decode token ids stayed bit-identical and the forward argmax was unchanged. Single run, no variance, CPU-bound; not a throughput claim.

Published 2026-06-15 · Version 3

Request-level batched-concurrent 4-bit decode for a 30B-parameter MoE model on a single Apple Silicon workstation. Batching B concurrent decode streams through one fused forward per token amortizes the per-token weight stream so dense weights are read once across the batch; per-stream output is byte-identical to serialized decode. B=4 aggregate reaches roughly 1.4x over a serialized baseline, plateauing near 35-37 tok/s at B=8. Honest finding: aggregate is sublinear in B and, against a separately optimized single-stream path, the batched plateau did not lead. Single-run, experimental.

Published 2026-06-15 · Version 3

On a single Apple M1 Ultra, a session-keyed setup cache amortizes the per-token host-side setup tax in a fused all-layer q4 30B-class MoE decode path. Reusing per-token setup state across a stable decode session, and rebuilding only on session or geometry change, drops host-side setup from roughly 29% to about 4% of the per-token wall. Measured single-stream steady throughput on an isolated decode benchmark rises 25.07 to 39.25 tok/s (1.57x), byte-identical greedy output. With the host tax gone, decode is occupancy-bound, distinct from a separately reported lower production-serving rate.

Published 2026-06-15 · Version 3

A CPU-only inference backend was brought up on a Raspberry Pi 4B (Cortex-A72, ARMv8.0-A) as hand-written ARM-NEON C++ with no BLAS/HIP/CUDA. Two dense decoders (~0.36B Llama-style, ~0.5B Qwen2-style) match a recent fp32 reference (cosine 1.0 and 0.99999988), byte-identical across two boards. On this bandwidth-starved target, 8-bit weight quantization and multicore threading are complementary, not additive: neither alone moved decode throughput; only Q8 plus four threads won (~9.83 tok/s, ~3.65x). A clock-sensitivity control confirms Q8 flips the workload compute-bound. Single measured run.

Published 2026-06-15 · Version 3

A governed runtime decomposes one request into a DAG of isolated, audited sub-agent ReAct loops, each with its own identity, isolated memory, allowed-tool limit, and audit chain. A bounded-concurrency scheduler runs independent tasks in parallel and merges them via a deterministic reducer with per-task audit references; partial failure gives a structured result, not a silent success. Each tool call passes a governor and commit gate; an injected side-effect is denied with no bypass on a real model. Verified with negative controls and a capstone. Deterministic planner; serialized decode.

Published 2026-06-15 · Version 3

A model-free policy classifies each request into one of five operator scenarios and lowers it to a typed decision over model, speculative-decode mode, retrieval grounding, and escalation, run live per request on one daemon with no restart. Simple tasks offload to lighter co-resident small-dense backends alongside a 30B-class quantized MoE on a workstation host. Single-run measurements show the smallest dense tiers beat the MoE single-stream path while a mid-size tier is an honest tradeoff; speculative decode is output-identical to greedy. No multi-run variance or mixed throughput claimed.

Published 2026-06-15 · Version 3

An independent implementation runs the full forward pass of a 26B non-autoregressive text-diffusion model via a from-scratch GGUF reader and dequantizer, with no external dense linear-algebra (BLAS) dependency. Parity vs a self-built llama.cpp golden on a short fixed prompt reaches per-row cosine above 0.9999997 and exact argmax over the full 262144-dim logits, pinning nine architecture facts that break parity if wrong. Bit-identical logits and argmax reproduce across Apple, AMD, and NVIDIA via real runs. Limit: forward logit fidelity only, not decode quality or convergence; single-condition.

Published 2026-06-15 · Version 3

On a frozen visual backbone, slot learning with a transformer mask-competition decoder learns an object partition that genuinely exceeds naive clustering of the same features, and is independent of it. An earlier apparent negative was traced to a target-normalization (whitening) bug in the reconstruction objective; removing it flips the result. The binding is weak-to-medium, plateauing modestly above clustering but well below reference object-centric segmentation — a characterized architecture/recipe ceiling. It is a semantic carrier / weak binding prior, not full object discovery.

Published 2026-06-14 · Version 3

Negative result. A world-state model that tries to DISCOVER a world's relations from per-object observations (the "grounding seam") does not beat feature models in a way that survives adversarial review. The apparent win on a homophilous citation graph is reproduced by classic feature-free label propagation, so the world-state machinery is not load-bearing. Relations inferred from features are too noisy to help; on heterophilous recorded graphs no relation or state model beats features. Useful relations are not discovered from features — they must arrive as high-precision observed events.

Published 2026-06-14 · Version 3

An architecture paper, backed by one prototype run, proposing two sovereign gates around agent execution: a Clarification Runtime (clarify under-defined input, asking only decision-critical questions) and an Outcome Runtime (stop iff target-state reached AND no mandatory actions remain), both following "a model may propose, a sovereign predicate disposes" over an event-sourced belief log. Crystallization makes a workflow the residue of a completed task. A single end-to-end test shows the thesis metric n1=3 -> n2=0, with a one-slot re-ask under retraction. Existence-proof, not benchmark.

Published 2026-06-13 · Version 3

Design note downstream of a cross-box latency result: a sub-millisecond consumer-Ethernet LAN makes within-layer tensor-parallel decode a regression, so aggregation must happen at the request boundary. The ranking (estimates, not measurements) puts data-parallel first (0 hops/token, prototype-stage; aggregate throughput is an HONEST heterogeneous sum across differing models, not a single-model scale-up) and pipeline second (~2 hops/token, a modest multiplier from low-latency transport tuning). A resident-memory rule keeps a 128GB Apple Silicon box single-resident, grounded in a real OOM crash.

Published 2026-06-13 · Version 2

A positioning and integration note, not a benchmark. Five sovereign-runtime deliverables are cohered into one capability set under one thesis: a sovereign AI execution runtime, not a local model runner. They span data-parallel routing with byte-identical failover, low-bit serving, a cross-chip decode-consistency report, an auditable hash-chained ledger, and a governed agent platform, all self-contained and event-sourced. No new measurement is introduced; the anchors are single-configuration observations. A concurrent-merge governance failure and its serial fix are recorded as a lesson.

Published 2026-06-13 · Version 3

A code-free research design for keeping an experience-reuse product loop converging toward fewer clarification questions, while never silently reusing a stale irreversible value. It models belief provenance (current-instance vs carried, via an instance scope the belief store lacked), a confirmation state machine over risk x provenance x source, and adversarially punches its own design through with six failure cases. Verdict: the thesis is not overturned, but the zero-question claim is restated to a safe form (reversible to 0, irreversible to an always-on low-friction confirmation).

Published 2026-06-13 · Version 2

Adversarial design paper (no code) attacking the assumption that a data slot carries a static risk class. A counterexample shows no static slot-to-risk label is correct in all contexts: an address is reversible editing a profile but irreversible seconds before dispatch of an order. Risk is a function of action, context, and the reversibility window, resolved at the commit site, not attached to data. This forces three layers — Memory, runtime Risk, and scoped Authorization — reframing a Memory System into a Commitment System bounded by provable reversibility. Experience is not authorization.

Published 2026-06-13 · Version 2

Adversarial integration of four probes against the Commitment System theory (Product Loop as commitment, not memory). Verdict NEEDS-UPGRADE; three of four facets break on real-world rails, none fatal. Root defect: the reversibility window is not a commit-site scalar but a shared, time-varying, stale-prone, third-party-owned belief. Risk inherits memory staleness; grant-currency is unstated (stateless-token revocation race); hatches relocate cliffs not remove them. Upgrade: four commit-site predicates plus a forced-commit branch, jointly bounded by reversibility and grant-currency decidability.

Published 2026-06-13 · Version 2

The commitment decision at an irreversibility boundary splits in two. The COMMIT ACTION is decidable: a terminating local recompute of currently-held belief, gated fail-closed. The FINALITY / safe-to-commit predicate is UNDECIDABLE: a claim about the unobserved future of a third-party-owned stream, isomorphic to Two Generals common-knowledge impossibility over a channel that acknowledges reversals but never finality. FLP and CAP are corroborating shadows; reopening makes finality non-monotone. The defensible deliverable is a conservative bound plus a tamper-evident audit, never a safety proof.

Published 2026-06-13 · Version 3

Four adversarial probes break the claim that an AI runtime can pre-allocate liability. Liability is post-hoc, fixed by realized harm, recoverability, counterparty, and jurisdiction; only authority, sign-off, and a backstop-plus-fault-regime are establishable before commit (cf. Price-Anderson, Montreal Convention, OFAC). Auditability is necessary but insufficient: causation is never in the log, so a separate adjudication layer is irreducible. The corrected non-identity chain adds two bridges, Liability-is-not-Solvency and Responsibility-is-not-Control, ending in a stipulated solvent backstop.

Published 2026-06-13 · Version 3

Capstone over a five-paper arc. A sovereign execution runtime is reframed as a series of refused collapses that a naive Believe-then-Act agent flattens: token vs world, reasoning vs capability, experience vs authority, knowledge vs reality, and authority vs liability vs solvency. Structurally it is a FOLD: authority delegates down, liability re-converges up via respondeat superior, audit is the spine. Every undecidable boundary is closed by an explicit STIPULATION BY FIAT, not by proof. "Sovereign" means both compute sovereignty and liability sovereignty. A paper synthesis, no implementation.

Published 2026-06-13 · Version 3

A sovereign Apple-Silicon engine serves a 30B sparse-MoE in packed-int4 (~15.4 GB resident vs ~60 GB at bf16). Folding all decode tokens into one GPU command buffer plus an on-GPU key/value write lifts single-stream greedy decode to a steady-state ~1.87x over a prior per-token path; a silent ~2x regression traced to an optimization gate shipped disabled by default. The path stays greedy byte-identical to a reference forward pass (cosine ~1.0) with zero vendor BLAS. An engineering/correctness result, not benchmark-scale or quality: single-run figures, still behind a popular external runtime.

Published 2026-06-13 · Version 2

Live two-chip consistency run: under greedy decode of one identical 4-bit quantized model on two same-architecture accelerator chips, 96.875% of decoded tokens are byte-identical (live, not replay). The ~3% residual is attributed to sub-f16-ULP tie positions — a determinism floor, not nondeterministic drift. A separate, strictly harder cross-backend test (two independent implementations of the same base model on different hardware vendors) breaks far earlier, confirming the property is specific to same-architecture, same-implementation runs. Smoke-scale, greedy-only; counts not recorded.

Published 2026-06-13 · Version 2

A GPU-resident packed-int4 decode path loads all layer weights to the GPU once and dequantizes on-chip, so no fp16 weight is materialized and there is no per-token host-to-device weight copy. On an idle 24GB-class consumer GPU, two layer subsets improve by 5.07x and 5.49x over a streaming baseline, bit-identical to streaming (cosine 1.0, argmax exact) by construction. Scope is narrow: two subsets, single-run, idle GPU, single-stream. The full-model resident figure is analytical only. No generation-quality or concurrency claims are made.

Published 2026-06-13 · Version 3

Prefill latency drops roughly 2.1x by making both the dense attention projections and the expert FFN FP8 (e4m3) and replacing per-token int4 expert dispatch with one grouped expert GEMM per layer, int4 weights dequantized to e4m3 on-chip. On a consumer 8 GB GPU, two single-run prefill configs show about 2.1x speedups versus the int4 baseline, at logit-cosine parity >= 0.997. Honest scope: single-run, two layer-depth configs, prefill-only; e4m3 cosine narrows with depth while staying above the parity gate. Parity is numerical agreement with int4, not a generation-quality measurement.

Published 2026-06-13 · Version 3

A hand-written tiled online-softmax flash-attention kernel for a video diffusion-transformer (DiT) self-attention operation on an RDNA2-class consumer GPU speeds that op 9.4x and the full standalone text-to-video pipeline from 1130s to 242s (4.67x), at cosine 1.0 parity versus the engine's own pre-flash attention path, with no vendor BLAS/attention library linked. Engineering result: the same arithmetic on a faster route, validated by numerical parity. Single-configuration, single-run; not a vendor-kernel comparison and not a generation-quality claim.

Published 2026-06-13 · Version 2

DAWM is framed as a next-state predictor rather than a next-token predictor: tokens, images, audio and documents are treated as observations of a latent world state, and the scarce problem is defining that state and having it emerge from observation rather than designing a new network. The position is stated as a research charter with three explicit falsifiable gates — carrier-independence, state emergence, and a scale-growing state advantage — each carrying an honest status. It is a hypothesis-level framing, not an empirical result.

Published 2026-06-13 · Version 3

A red checkpoint, kept honestly. On a CUDA stream-resident text decode path using 4-bit quantized weights on consumer-class GPU hardware, an end-of-sequence handling fix made generation stop correctly at the EOS token, but a separate forward-quality degradation persisted, so output stayed wrong. Logged red with no metrics: no trustworthy reference oracle existed yet, because the quantized weights would not load into a standard reference framework without specific older library versions (newer stacks random-initialize experts). Records the before-state; the oracle fix is in a separate note.

Published 2026-06-13 · Version 3

Engineering milestone: a sovereign Whisper-tiny ASR path (mel spectrogram to encoder to decoder to greedy decode) was integrated into two engines and asserted by a green test suite (no failures) against a bundled golden reference. This is golden-parity correctness-smoke, NOT a WER/accuracy or throughput result; a release build is required for practical run time. Scope is limited to Whisper-tiny greedy decoding only — larger models, quantization, beam search, and streaming are untested.

Published 2026-06-13 · Version 3

A model-free input gate (state runtime plus epistemic guard, no language model loaded) is probed with an 8-test suite across four gates: under-defined tasks trigger clarification while a fully-specified task proceeds (negative control); only decision-critical questions are asked (four to three); an outcome predicate separates approval-pending from done; and a thesis metric shows such questions falling from three to zero after crystallization. Claimed: the model-free floor holds. NOT claimed: free-text goal parsing, question wording, throughput, latency, or benchmark-scale tests.

Published 2026-06-13 · Version 3

Four separately validated modules (clarify, state, skill, epistemic-guard) compose into one thin sovereign facade running a full model-free clarify-execute-verify loop. A single end-to-end test self-produces the metric: an under-defined run surfaces questions and stops, a pre-bound run of the same class asks none, a control re-asks exactly the one retracted irreversible slot. A fail-closed gate makes irreversible decisions re-derive live authority, not reuse a stale belief: reversible questions reach zero on repeat, irreversible ones always confirmed. A correctness proof, not a benchmark.

Published 2026-06-13 · Version 3

This note frames world modeling as next-STATE prediction, not next-token prediction: tokens, images, audio, and documents are observations OF a latent state, not the state itself. It packages a foundational State Contract -- an anti-drift definition of what qualifies as state across six conditions (from predictive sufficiency to rendering invariance to inspectability) -- with a concrete Observation -> Event -> Fluent realization that keeps outcomes and verdicts out of the event layer. Three falsifiable gates are attached; only the first is partially earned, on hand-authored micro-worlds.

Published 2026-06-13 · Version 3

An index over a structured-state reasoning program's named findings, each recorded as a working mechanism (a primitive, repair, or applied use) or a boundary (a characterized limit or honest negative). It is a navigational map over positive results and bounded hypotheses; it discloses no claim mapping, configuration value, threshold, or recipe. Several entries are kept as standing limits, including negative repairs that failed their acceptance bar. Mechanisms span a semantic-state substrate, an observability and gating protocol, edge-decode decomposition, and a cost-aware routing primitive.

Published 2026-06-13 · Version 3

A single dense inference engine with no vendor BLAS and no third-party ML framework reproduces HuggingFace next-token logits at cosine >= 0.999979 (f16) across 15 transformer families spanning three positional paradigms and both attention and non-attention (SSM/RWKV) sequence mixers. Per-mechanism ablations confirm each reimplemented component is load-bearing, with no cross-family logit regression. This is a correctness-reproduction result at smoke-test scale (1-2 prompts per family), bounded by an f16 ceiling - not a generation-quality, throughput, or benchmark claim.

Published 2026-06-13 · Version 3

[SUPERSEDED] Two results on an object-emergence milestone for unsupervised slot-binding. (1) A box-derived evaluation gold (bounding boxes used as masks) caps even oracle clustering below a common pass bar, while real instance-segmentation gold rises above it — a measurement-artifact caution that still holds. (2) A then-apparent negative, that frozen-backbone slot-binding did not beat naive clustering, was later traced to an implementation bug and overturned. Retained for the scientific trail.

Published 2026-06-13 · Version 4

Higher-fidelity revision of an earlier negative result on cross-box tensor-parallel (TP) decode. TP-splitting one model's decode across two boxes needs a synchronizing all-reduce per layer, so per-token cost is latency-bound. With a real two-sided heterogeneous GPU all-reduce (~250 us/barrier) and a ~42 ms/token single-box baseline, compute/2 + comm gives ~33 ms/token at 48 fused barriers (~1.27x) and ~45 ms/token at 96 unfused barriers (~0.93x). The original 0.35-0.6x collapse is refuted; the worst case is a mild ~7.5% regression unless barriers fuse. A projection, not a timed decoder.

Published 2026-06-13 · Version 2

Skill Runtime activates a learned, parameterized action pattern instead of re-deriving it, removing the planning round-trips re-derivation pays: a structural four-to-zero reduction. One single-run small-model case was byte-correct, its large wall-clock win latency-dominated and non-generalizable. A model-free, embedding-free inverted index over intent tokens keeps matching flat and precise as the library grows. Acquisition stays sovereign: a model-free miner is producer of record; a teacher only proposes behind a model-free judge. Distillation by a too-small model failed. A smoke test.

Published 2026-06-13 · Version 3

Three positive mechanism findings from object-emergence work in slot-based representation learning. A slot-diversity anti-collapse penalty developed on synthetic micro-worlds transfers to real COCO images, keeping slots distinct over a long run (pairwise similarity near zero). Reconstruction shows a second, distinct decoder-side collapse mode (single-slot-per-image), fixed by a separate mask-entropy balance term. Frozen self-supervised ViT features already carry object structure (k-NN purity ~0.70-0.80). Mechanism and ablation findings, not an object-emergence claim.

Published 2026-06-13 · Version 2

An independently implemented selective-scan state-space (Mamba-style, 130M-class) forward pass, built without the reference SSM GPU kernel library, reproduces a HuggingFace transformers f16 prefill-logit reference at cosine 0.999997, argmax 8/8 across two prompts. A kill-selectivity control removing input-dependent selection collapses parity to cosine -0.73 (0/8), showing selectivity is load-bearing, not incidental. This is the engine's first non-attention (state-space) sequence-mixing paradigm. Scope: an f16 logit-parity smoke test, not a benchmark; no quality, throughput, or quantized claim.

Published 2026-06-13 · Version 3

A correctness-validation port of the RWKV-4-169m hand-written WKV linear-attention/RNN recurrence (pre-LN, token-shift, fp32-state max-trick, time/channel-mix gating; no attention or KV cache) into a self-built dense ROCm engine on one consumer-class AMD GPU. Against a Hugging Face transformers oracle on identical token ids, f16 prefill logits matched at cosine 1.0, argmax 12/12 across 12 positions; a kill-WKV control fell to 0.96 (3/12), so the recurrence is load-bearing. A single-run forward-parity smoke test on one small model; not a quality, throughput, quantized, or larger-model result.

Published 2026-06-13 · Version 3

Sovereign (no vendor BLAS) port of Bloom-560m to an in-house ROCm dense inference engine on an RDNA2-class GPU reproduces a Hugging Face transformers f16 prefill-logit reference at min cosine 1.0 and argmax 6/6 over 6 token positions. It adds ALiBi (per-head linear pre-softmax bias) and a pre-block embedding layernorm, completing coverage of all three positional paradigms: RoPE, learned-absolute, and ALiBi. A negative control surfaced a latent NaN bug in the generic rotary path; guarding it off restored parity. Correctness smoke test only: no quality, throughput, or memory measured; f16 only.

Published 2026-06-13 · Version 2

Correctness port of a parallel attention+MLP block (Falcon-7B-Instruct) into an independent, vendor-BLAS-free dense engine on a consumer GPU. One input layernorm feeds both sublayers, summed into a single residual update, unlike sequential families; it adds multi-query attention and an exact-erf GELU. At f16, prefill-logit parity versus a public reference reaches cosine 1.0 with full argmax agreement on a two-prompt smoke test, while a force-sequential control collapses to cosine 0.977 with no matches, showing the parallel structure is load-bearing. f16-only; no quality or throughput claims.

Published 2026-06-13 · Version 3

A fully-sovereign text-to-video pipeline for Wan2.1-T2V-1.3B on Apple Silicon: a prompt string runs end-to-end in-process (tokenizer, UMT5 encode, UniPC schedule, DiT denoise with CFG, 3D-VAE decode to frames), every linear via Apple's Accelerate BLAS, no third-party ML framework (no diffusers, no torch) in path. Against an fp32 diffusers reference under matched seed/schedule it reaches per-step latent cosine 1.0 and frames cosine 1.0 at PSNR 73.3 dB. A single-prompt numerical-parity check, not a throughput, quality, or larger-variant claim; the naive 3D-VAE causal conv dominates wall time.

Published 2026-06-13 · Version 3

First hand-written sparse mixture-of-experts FFN (router top-8 of 64 experts, weighted SwiGLU sum, un-renormalized router weights) in a previously dense-only engine, validated by f16 prefill-logit parity vs a HuggingFace oracle for OLMoE-1B-7B on an AMD RDNA2 (gfx1030) GPU. It also isolates a load-bearing config trap: the config omits the RMSNorm epsilon, and an assumed value 10x too small capped parity near cosine 0.99 because the normalized signal variance was near epsilon; the correct value restored cosine 0.999999, argmax 8/8. A correctness result, not a throughput or benchmark evaluation.

Published 2026-06-13 · Version 2

Sovereign port (no vendor dense-matmul library) of IBM Granite-3.1-2B to a ROCm dense engine, validated for f16 prefill-logits parity vs a Hugging Face transformers oracle: cosine 0.999997 with full argmax match on a consumer RDNA2-class GPU. The forward is a standard Llama-style stack plus four scalar multipliers (embedding, residual, attention, logits). Negative controls show embedding, residual, and attention multipliers are load-bearing; disabling the global logits multiplier still passes — invariance of cosine/argmax, not proof of irrelevance. A small-sample correctness smoke test only.

Published 2026-06-13 · Version 3

An independent dense-engine port of OLMo-2-1B (AllenAI) validates its departures from a standard pre-norm block: no input normalization, reordered post-normalization on sublayer outputs before they rejoin the residual, and full-dimension QK-normalization. Against a recent Hugging Face transformers reference, f16 prefill-logit parity reaches min cosine 0.999998 with argmax 12/12; an int8 path (0.998700) is reported, not claimed equal to f16. A loader bug that overwrote the MLP-norm slot was rooted and fixed by a model-specific guard. Correctness smoke test only; no quality or throughput claim.

Published 2026-06-13 · Version 3

A from-scratch port of StableLM-2-1.6B (Stability AI) onto a dense ROCm engine that avoids vendor BLAS/DNN libraries. It adds two engine firsts: partial RoPE (rotary span 16 of 64 head dims, NeoX split-half) and a first non-RMS normalization path, LayerNorm-with-bias, plus QKV bias. Against a Hugging Face transformers f16 reference on identical token ids, prefill-logits parity reaches cosine 0.999997 (12/12); q8 reaches 0.998910 (11/12). A full-RoPE control collapses to -0.62 (3/12), so the rotary span is load-bearing. Correctness validation only: a small-sample, single-run smoke test.

Published 2026-06-13 · Version 3

A sovereign port of Phi-3-mini-4k into a dense inference engine that direct-loads the model's fused projection tensors — one concatenated Q/K/V and one concatenated gate/up projection — as single tensors, rather than pre-splitting them at load. Under f16 it reproduces a HuggingFace transformers reference's prefill-logits at cosine 1.0 with full top-1 (argmax) agreement on a short stimulus; the 8-bit path reaches cosine 0.999996. Scope is narrow: a forward-pass numerical-fidelity smoke test only — not generation, throughput, latency, or long context (unwired; 4k plain-RoPE only). Mini only.

Published 2026-06-13 · Version 3

A correctness-validation method for inference engines: the engine dumps per-token logits, and an offline harness compares them against a HuggingFace transformers oracle on identical token ids with the same weights, gated on cosine similarity with argmax agreement reported. Two small dense families pass cleanly (cosine well above 0.9999). A process finding: a 30B AWQ compressed-tensors per-expert int4 model yields a garbage oracle unless the loader is version-pinned, because newer stacks silently random-initialize the experts. Parity is not quality; the sample is a small dense smoke test.

Published 2026-06-13 · Version 2

A dependency-free CUDA inference path (no vendor BLAS/DNN/TLAS libraries) adds paged KV caching (a global block pool with per-(layer, sequence) block tables, allocate-on-demand and free-on-exit) plus iteration-level continuous batching. On an idle consumer GPU, batched per-stream argmax output is byte-identical to single-stream decode across small batch and block sizes, and aggregate throughput modestly exceeds single-serial decode. Aggregate is NOT linear in batch and was not benchmarked against an external serving system. This is a correctness smoke test on a layer subset, not a benchmark.

Published 2026-06-13 · Version 3

Engineering retrospective on a multi-week debugging campaign in an Apple Silicon 4-bit Metal inference engine. Command-buffer folding exposed an encoder memory leak; its fix surfaced a cold-bank allocation throw, closed by a pre-expanded memory-bank reservation and a precondition guard. A NaN first blamed on reallocation during encoding was retracted as benign. On real shards the production config hit near-exact parity (cosine ~1.0, PASS); batch-4 decode throughput reached ~1.40-1.43x over single-stream. A bug-fix result, not a benchmark; parity is numerical equivalence, not a quality claim.

Published 2026-06-13 · Version 3

A true standalone, vendor-BLAS-free text-to-video pipeline on one AMD RDNA2 GPU (gfx1030) runs in-process from a prompt string to decoded frames, nothing injected from a reference: text-encoder embeddings, a self-contained FlowMatch-Euler schedule, a 20-step CFG denoise over a Wan video transformer, and a Wan 3D-VAE decode. Every linear is a hand-written GEMM, no vendor BLAS. Against a diffusers fp32 oracle (matched seed/schedule), prompt/negative embeddings, early latents and frames match at cosine 1.0 (PASS). Correctness/sovereignty result, not throughput or quality; single config.

Published 2026-06-13 · Version 2

A self-contained CUDA Wan2.1 text-to-video pipeline performs a live UMT5 text encode (no prompt embeddings injected from the reference), denoises with classifier-free guidance over the Wan DiT, and decodes through the 3D-VAE. Against a diffusers reference with matched seed and schedule, early-step latents and output frames reach cosine 1.0 with frame PSNR ~89.8 dB, using a dependency-minimal build that links the CUDA runtime only (no cuBLAS). Scope: a correctness/oracle-parity validation on one consumer-class NVIDIA GPU run — not a generation-quality, throughput, or benchmark-scale result.

Published 2026-06-13 · Version 3

A 1024px image-generation pipeline runs end-to-end on a consumer-class RDNA2 GPU with the vendor BLAS library fully stubbed out, reaching final-latent cosine 0.99999999 against a reference diffusion implementation (gate >= 0.999) and exiting cleanly. The primary contribution root-causes a deterministic post-denoise segfault: a missing output-directory argument yielded a NULL file handle whose unguarded write dereferenced NULL before decode; the fix creates the directory and guards the writes, with no kernel or numerics change. A correctness-validation result, not a throughput or quality claim.

Published 2026-06-13 · Version 3

A from-scratch Swift CPU reimplementation of the Wan2.1 AutoencoderKLWan decode path reaches cosine 1.0 against the diffusers reference, independently pinning three contracts the video pipeline depends on: the z latent layout, causal-convolution semantics, and temporal-upsample behaviour. This is a single-figure, decode-only correctness anchor, not a throughput or generation-quality result. CPU naive convolution is slow, and the encode side and other VAE variants are out of scope.

Published 2026-06-13 · Version 3

Portability fix: the CUDA image/video generation pipelines previously required box-specific prebaked weight layouts and could not run on a fresh consumer-class (sm_89) CUDA box. The video DiT and VAE now load directly from public Hugging Face safetensors (byte-identical keys), and the image pipeline rebuilds its weight root from public HF SDXL on any box. Verified parity vs the prior pipeline: video frames cosine 1.0, image 1024px cosine 0.99999995, self-contained runtime. The image VAE needs the fp32 shard (fp16 degrades decode). A correctness smoke test, not a throughput or quality result.

Published 2026-06-13 · Version 3

A hand-written ("sovereign") HTTP reverse-proxy router fronts a data-parallel inference fleet and, on a mid-generation backend drop, greedily resumes the request on another backend, continuing byte-identically away from floating-point ties so the user sees no seam. Correctness is inherited from a separate cross-chip determinism result, not measured internally: no router-internal failover rate, latency, or seam count is recorded. This is an engineering/architecture report of seam-free, audit-logged failover under greedy decode; sampled decode and load/performance optimality are out of scope.

Published 2026-06-13 · Version 3

Design note: model agent world-state as an event-sourced belief log, not chat history. Outcome-free events (assert/update/supersede/retract) fold via a pure reducer to a belief state (state = reduce(events)); answers are served from the reduced state, and retracted or contradicted facts are never served confidently. It is positioned as the shared substrate beneath the clarification and skill runtimes (crystallize = assert, pre-bind = reduce) and is replayable and auditable. No measurements are reported; extraction quality and large-log scale behaviour are out of scope.

Published 2026-06-13 · Version 3

Skill acquisition gated by a model-free judge, not any teacher. On a small correctness probe, a model-free pattern-miner qualified all of its trajectories while a judged large teacher qualified none of its own: the teacher's structure was sound, but its output discipline failed the judge. Teachers only propose on the residual the miner cannot cover, and every proposal must clear a deterministic format-normalizer plus the same un-bypassable judge. Small-model distillation qualified none. Authority is the judge; this is a smoke test, and qualification gates output discipline, not skill quality.

Published 2026-06-13 · Version 3

Can two renderings — text and visual — of a situation encode into the same inspectable semantic graph state in a hand-built small-cell schema? Cross-rendering structural agreement was initially floored at zero: a free edge-slot schema lets encoders converge in dense space yet disagree on discrete bindings. An oracle decomposition isolates the dominant wall as ungrounded edge-endpoint binding, not entity-identity collapse. Coordinating edges by entity-pair and factorizing the relation decode into label, direction, and edge-existence channels lifts agreement off the floor across three seeds.

Published 2026-06-13 · Version 3

A design discipline, not an experiment: an in-loop epistemic gate that resolves every agent answer to one of three verdicts — confident (grounded in available evidence/state), abstain (insufficient evidence), or external-truth-required (verified outside the system). By construction, a stale or retracted belief can never be served as confident and an over-privileged skill step is denied before any side effect; unknowns route to ask, not guess. The clarify, skill, and state runtimes inherit it. No measurements: efficacy is asserted by construction, not yet validated.

Published 2026-06-13 · Version 3

A sovereign-first ReAct agent harness combining a function-calling-shape tool registry, tool-result message threading, a bounded loop guard, short-term per-task memory, and an in-loop governance gate routing every tool call through a governor and audit before dispatch. The loop plumbing passes its full self-test suite with a model-free harness. Claimed: correct ReAct-plus-governance plumbing under test. Not claimed: end-task quality (model-dependent), tool breadth, or any throughput, latency, or scaling property. This is an engineering-correctness result, not a task-quality benchmark.

Published 2026-06-13 · Version 3

Design note: a prototype settlement substrate for a multi-node compute fleet, composed entirely from OS-native cryptographic primitives (no blockchain SDK, no external chain). Nodes self-certify with Ed25519, sign their bids, exchange double-signed receipts, and append events to a persistent SHA-256-chained, append-only, tamper-evident ledger. The architecture and its sovereignty-by-construction are described; no throughput, latency, or scale is measured. Explicitly not BFT, not consensus, not market-optimal — it assumes cooperating nodes within a single operator trust domain.

Published 2026-06-13 · Version 3

A multi-milestone study of a persistent belief runtime: a reasoning cursor walking an accumulated multi-turn graph of committed facts. Extraction and commitment are separable: a small learned write policy plus a deterministic edge filter repairs the adversarial-poisoning tail without retraining the runtime. Selectively forgetting prior-turn facts has an interior optimum improving reasoning and adversarial safety together; memory is weighted, not binary. Arbitration (which fact to follow) and calibration (is evidence decidable) are distinct computations one routing softmax cannot share.

Published 2026-06-13 · Version 3

A study tests carrier-independence: whether a learned next-state predictor maps one situation, rendered as text, a visual canvas, a structured trace, a symbolic schema, or a corrupted variant, into one shared semantic state. An external review forced a scope correction: only SOFT convergence is shown (retrieval-band agreement among controlled symbolic renderings). The HARD shared-graph form sits at the random-pairing floor, so strong carrier-independence is NOT verified and natural multimodal grounding is untested. A value-erased schema cannot support a value-mismatch negative control.

Published 2026-06-13 · Version 3

Phase 10 of the DAWM program asks whether several independently developed small-cell primitives — semantic-state formation, scoped candidate control, rendering-invariant state with contradiction localization, and activation-graph cursor execution — can integrate in one pass without any component regressing the observability of others. We report a preliminary integration smoke harness, not a full Phase 10 closure: all per-component checks pass together across two seed sets and two environments, with no regression. The finding is integration coherence on an engineered domain, not a scale claim.

Published 2026-06-13 · Version 3

A controlled symbolic rendering-invariance study, rebuilt after an earlier pass overstated shallow probes. Its central contribution is failure separability: each error class is observable through its own failing control. The work advances to two independent learned non-text parsers (graph and table) mapping distinct renderings of one semantic state to a shared canonical state, which drives downstream scope/candidate execution and state-level contradiction detection with localization. A bounded review closed the cell narrowly, excluding native-multimodal and open-world claims.

Published 2026-06-13 · Version 3

A two-part negative result on learning a variable-cardinality semantic schema where multiple encoders each emit a fixed-width set of entity slots under a permutation-invariant set-reconstruction loss. Part one names a reproducible collapse mode, the slot-stationarity boundary: without slot-identity anchoring, each slot's target drifts batch-to-batch, so every slot converges toward the mean of its targets and the set collapses — at the embedding level, not the decoder. Part two tests three distinct repairs across seeds; none clears the bar, each failing differently, reinforcing the boundary.

Published 2026-06-13 · Version 3

Learned cursor routing in an activation-graph workspace model is studied as a two-step negative-then-repair campaign. The first attempt failed and exposed two boundaries: the test cell offered no genuine routing ambiguity, so a learned policy equaled a fixed rule, and the abstain decision would not converge under behavior cloning. A successor applied cell-, policy-, and loss-level fixes, reached a multi-seed success while preserving full execution-trace observability, and surfaced a third boundary: deferred commitment adds value only when greedy commit sits below the answer-accuracy ceiling.

Published 2026-06-13 · Version 3

DAWM Phase 9 develops the DAWM cursor from a deterministic activation-graph probe into a learned, cost-aware routing policy and a budget-gated multi-step rollout controller, asking whether semantic state can be executed as an explicit cursor trajectory rather than dense re-evaluation. It yields one positive routing mechanism and three honest boundaries: when economic optimization helps, how a budget-aware controller pre-empts paths it predicts it cannot finish within budget, and why auxiliary control heads need active-role supervision. Concrete thresholds are held out of the public tier.

Published 2026-06-13 · Version 3

Can a predefined hierarchical semantic scope improve local precision by shrinking the range of active semantic candidates, without tunnel vision that loses facts in neighbouring scopes? Through a chain of controlled closures -- hard scope, soft/overlapping scope, conflict-conditioned dynamic expansion, a learned trigger, a lexical-leak falsification campaign, and a two-stage split of conflict detection from secondary-scope selection -- this study gives mechanism-level evidence that local precision is governed by the active candidate range. It is fully controlled, with no real-domain claim.

Published 2026-06-13 · Version 3

A dual-channel reasoning cursor cleanly separated arbitration from calibration but left the underlying feature-side noise floor in place. Reframing contradiction as a bounded semantic-depth regime then yielded regime-selective compression: it pruned unresolved-contradiction candidate space hard while preserving and even improving resolved-evidence reasoning. A local typing heuristic exactly recovered an oracle on resolved contradictions but not on tied ones, revealing a structural information ceiling. Two contributions follow: a semantic-state substrate and a controlled-cell protocol.

Published 2026-06-13 · Version 2

We describe a design in which all consequential actions taken by an AI agent are routed through one policy-enforcing execution boundary, with human approval required for irreversible actions and evidence captured for audit and rollback. This report documents the design and internal, scenario-based observations. It is not peer reviewed and makes no benchmark or safety-guarantee claims.

Published 2026-06-01 · Version 1.0

A short, non-peer-reviewed note summarising internal observations on when local, on-device inference is already sufficient for representative tasks, and where hosted inference remains necessary. Numbers are hardware-specific and are not a universal ranking.

Published 2026-05-20 · Version 0.2