Superseded: the Hanzo GitHub App pushes a webhook, so the forge tracks GitHub
without a per-repo workflow. This file called git.hanzo.ai/api/v1/.../mirror-sync
— a Gitea API for a system we no longer drive — and would sit inert in every repo.
One mechanism, in one place, instead of ~350 copies of a cron.
Two commits removed this repo's GitHub workflows without writing the native
replacement they named, so nothing built the papers or the site image and no
run failed to say so. papers.hanzo.ai has served a frozen Pages build since.
Restore both into .hanzo/workflows, which the forge reads:
- ci.yml from 8185428^ build-papers.yml. Compiles with `make -k all` so one
broken paper does not hide the rest, then asserts every expected PDF exists.
The predecessor could not fail: every Makefile rule ends in `|| true` and
prints FAIL instead of exiting. Drops the v<run_number> Release and the
commit-PDFs-back step, which wrote to what is now a mirror.
- deploy.yml from ad31900^ deploy-site.yml. Builds and pushes
ghcr.io/hanzoai/papers:<sha> and does not deploy; the universe CR names the
tag that is live. Authenticates to ghcr with REGISTRY_TOKEN, since a
forge-issued GITHUB_TOKEN authenticates nothing there.
Makefile gains `manifest`, the expected PDFs one per line, so the gate reads
ALL_PDFS rather than restating which papers exist.
.github/workflows/sync.yml becomes the canonical push-refs workflow from
universe infra/ci/sync.yml, replacing a mirror-sync nudge that documented
GitHub as upstream and asked the forge to pull.
Co-authored-by: Hanzo Dev <[email protected]>
git.hanzo.ai mirrors this repo by PULL on a ~10-minute interval, and arcd runs
CI/CD there — so every push waited out that interval before anything built.
This asks Gitea to pull HEAD immediately.
Latency only: the repo already mirrors via the App webhook, so a missing
HANZO_GIT_TOKEN or a failed curl is non-fatal and never fails the push.
Idempotent (mirror-sync just pulls HEAD) and concurrency-coalesced.
This workflow ran on a self-hosted actions-runner-controller pool. ARC is
being decommissioned: CI executes inside git.hanzo.ai (Gitea Actions,
.hanzo/workflows) and delivery is cd.hanzo.ai reconciling the reviewed image
pin in hanzoai/universe. GitHub is a mirror and runs nothing.
Removed rather than repointed — there is no GitHub-side pool to move to, and
leaving it would keep ARC load-bearing.
This workflow ran on a self-hosted actions-runner-controller pool. ARC is
being decommissioned: CI executes inside git.hanzo.ai (Gitea Actions,
.hanzo/workflows) and delivery is cd.hanzo.ai reconciling the reviewed image
pin in hanzoai/universe. GitHub is a mirror and runs nothing.
Removed rather than repointed — there is no GitHub-side pool to move to, and
leaving it would keep ARC load-bearing.
The *.pdf ignore rule in this repo is commented out and 511 PDFs are already
tracked, so the compiled artifact belongs beside its .tex source rather than
being the one paper you cannot read without a LaTeX toolchain.
One server, one version, one tag spelling. v0.5.1 is the only tag carrying
79ac4f9 (serve directory index in place), so stale pins served a DIFFERENT
URL contract: docs.hanzo.ai still 301s /x/ -> /x/index.html while every
v0.5.1 host does not. Also 0.5.1 (yadota) was never published as a tag, and
the -amd64 suffix leaked an architecture (a place) into a version (a value).
Adopt the Metal lane's byte-comparable protocol: three verbatim workload classes, gamma sweep,
multiple + vs-llama + lossless. Provisional Metal reference (1.23x WIN sustained-reuse @ g8),
re-measured per backend at battery via spec_decode.sh, stamped to the spec cut (novel floor
0.47->0.71x at ml 0.11.91). results-spec.tex seam; kernel board untouched.
Decode was measured stochastic vs llama greedy (an unstated control). Corrected greedy:
Metal 0.72->0.92, ROCm 0.72->0.85, Vulkan 0.52->0.60, CUDA 0.84 (device sampler, tax~0).
Adds the erratum, makes sampling parity a required protocol control, revises the abstract/
BW/model-size/conclusion, updates the roofline (Vulkan 120 vs 199 GB/s, measured 213 peak).
The correction increases the decode standing and the paper's credibility.
Systems paper + numbers-as-data results. Honest board (Qwen3-1.7B-Q4_K_M, N=7, 95% CI):
prefill at parity (CUDA WIN 1.09x at pp4096); decode behind on all four backends
(CUDA 0.84, Metal 0.72, ROCm 0.72, Vulkan 0.52), decomposed into APU bandwidth-utilization
(measured 213 GB/s peak; llama at 93%, us at 48-72%) and discrete fixed-overhead that a
4B control amortizes. Root-causes the Vulkan pp4096 cliff (not VK_WORK_CAP -- refuted).
Overturns several internal claims against a properly-built baseline. latexmk-clean.
Add the kernel-DSL campaign pair:
- refutation-driven-perf (Paper 08): the refutation-log methodology and
measured win ladders across gfx1151 / GB10 / M4 Max.
- evolutionary-schedule-search (Paper 09): schedule search over the
monomorphized DSL and the continual-improvement loop it anchors.
Each ships root .tex + .pdf, a served copy under site/public/pdfs, and a
site catalog entry (site/src/config/papers.ts) with a companion cross-link.
INDEX.md regenerated via `make index` (218 papers, 211 compiled).
11pp. Real executed benchmark numbers (enso-bench results/*.json via emit_paper.py):
GPQA-Diamond enso 87.9 / ultra 90.4, HLE 29.4/29.2, LiveCodeBench 91.4/85.1,
CharXiv 78.0/81.5, with per-benchmark metered costs. Includes routing-overhead,
economics (1% aligned meter), and honest-reporting/limitations sections. PDF
rebuilt fresh against the v2 verify-then-select results (committed PDF was stale).
Grounds the paper's "inter-subsystem calls are in-process function calls, no
network hop" claim (§compare, axis 3) with a real number and a functional axis:
- Co-resident usage read (finance.ListUsage, one SQLite scan of the org's file):
1.25 ms / 100 rows, 10.5 ms / 1000 (measured, GB10, cgo/SQLite) — zero network
round trips, vs the mesh's billing→ledger hop + (re)serialization per read.
- The discipline it exacts (stated honestly, we paid for it in an outage):
in-process composition must be by REFERENCE (finance.Current().ListUsage), not
in-process HTTP that re-routes by path (which re-enters the caller when the
callee's route isn't compiled in); and the balance gate must gate writes/metered
compute, never plain reads.
- A per-subsystem functional smoke (cmd/smoke) probes one read on each of 38
mounted subsystems through the single binary and fails the release on any
402-on-read or 5xx — functional evidence for "one binary, 56 subsystems".
Reproducibility addendum gives the exact bench + smoke commands and the host.
Co-authored-by: hanzo-dev <[email protected]>
Token IDs are a bijection with a published dictionary, so storing them is
storing the prompt. Frozen-backbone embeddings are trained to preserve
meaning, and that faithfulness is exactly what inverts — Morris et al. recover
most short inputs verbatim from the vector alone. Both get called
anonymization. Neither is.
The stronger position is to not retain. Training wants a gradient; the request
is the courier that carries it. Once the update lands, keeping the courier buys
no learning and all of the risk. A retention window is a promise; an absent
column is a fact.
The argument's force is that it costs nothing — the low-dim features a router
needs are cheaper to compute, cheaper to store, and on the evidence of the
router already serving our traffic, sufficient. Privacy and efficiency here are
one constraint seen twice, because both follow from minimality.
Includes an audit of our own ledger, which fails this today: it persists a
frozen-backbone embedding under a comment asserting 'never prompt text' — true,
and doing a false job. A privacy argument never run against its author's own
code is a marketing claim, so the check is the contribution.
The paper described "Mixture of Distilled Experts": experts distilled from dense
teachers into a 480B/47B model with semantic routing, reported at MMLU 91.2. That is
not what MoDE is, and that model does not exist. The name, the mechanism, and every
number in it were wrong.
The real architecture (zenlm/zen5, with extraction + router-training code) is the
inverse: experts are HARVESTED FROZEN from six independently-trained open families
(Qwen3.5 Gated DeltaNet, MiniMax-M2.5 Lightning Attention, GLM-5, Kimi K2.5 DeepseekV3,
Ling-1T FP8) plus vision/video/3D/audio, and only ~394M parameters are trained — a 207M
complexity estimator, a 134M cross-architecture alignment layer, and a 52M router, or
0.013% of the ~3.1T pool. Diversity is the point: nothing is distilled, because the
expensive artifact is already published. Routing is complexity-aware and hierarchical —
the tier is predicted from the first 64 tokens, so a greeting costs 0.8B active and a
proof costs 100B+, with mid-generation escalation when confidence drops.
Every benchmark table is deleted rather than corrected. The evaluation is in progress
(scripts/benchmark.py) and will be published when the numbers are measured. The claim —
frontier capability at router-training cost — is worth testing honestly; a fabricated
table only obscures whether it holds.
Re-dated 2026: the paper said June 2025, but the experts it routes over (Qwen3.5, GLM-5,
Kimi K2.5, MiniMax-M2.5, Ling-1T) did not exist then. Credits ReMoE and MoE++ (both
ICLR 2025) as the published results MoDE builds on.
The paper has been in the repo since it was written (hanzo-router/main.tex,
indexed in INDEX.md) but was never added to the site config, so
papers.hanzo.ai/hanzo-router 404s — including from the "Read the paper" card on
the docs Smart routing page and the hanzo.ai landing, both of which cite its
cost analysis.
A page exists when the paper has an entry here (generateStaticParams maps over
siteConfig.papers) and a PDF at the pdfUrl, so this adds the entry alongside the
other engine/AI-infrastructure papers and publishes the built PDF. The abstract
keeps the paper's own scope line: it claims no measured benchmark saving, only
an itemized cost model.
The Film Is Not a Context Window: a 3-hour film is ~2000 shots of 3-8s,
coherence decomposes hierarchically, the persistent state is a small
structured film bible (not a context window), and long-form generation
is orchestration+conditioning over short-horizon generators. Formalizes
the 5-layer coherence stack (story/entity/shot/style/audio), the cut as
a free reset that bounds chunk-AR drift to one shot, error accumulation
(intra-shot drift vs cross-shot dispersion), the render as an
embarrassingly-parallel throughput job (idempotent shot-hash DAG, bible
prefix-cache), and film-specific open problems. Cross-references the
games and distributed companions without duplication; all feature-length
numbers labelled projection, substrate numbers measured+cited.
New paper hanzo-generative-games.tex (13pp). Thesis: a playable generative
game is an inference-systems artifact -- the frame is the token, an action-
conditioned world model in a fixed-shape frame loop. Core section is the two-
regime frame latency budget (graph-favorable denoise loop vs compute-bound VAE
wall, cured by a tiny distilled encoder). Adds the modality pipeline matrix
(honest measured/in-port/planned), the canonical-f32 ring as a neural render
farm, edit-while-running as prefix reuse, and game-specific open problems --
centrally the speculative-decoding = client-side-prediction isomorphism.
Cross-references the distributed-inference series; world-model landscape
licenses verified from HF/GitHub primary sources. Index regenerated.
Four papers on heterogeneous distributed LLM inference:
- hanzo-heterogeneous-distributed-inference: cross-vendor (AMD ROCm gfx1151 +
NVIDIA GB10 CUDA) tensor-parallel decode over a 2.5GbE cable, coherent at
50.4 tok/s (TTFT 0.09s, 213 tok/s prefill). Root cause of prior corruption
proven: per-backend auto-dtype (ROCm->f16, CUDA->bf16) reinterpreted raw on
the wire. Fixed by a canonical f32 ring wire + world_size-1 accumulating
all-reduce (correct for any N>=2; spurious power-of-two gate removed).
Same-vendor f16+f16 control matches token-for-token.
- hanzo-distributed-open-problems: NEW companion enumerating 8 open research
problems (sampling-determinism boundaries, quant-aware TP sharding, PP
layer-assignment ILP, adaptive speculation under RTT/acceptance drift, the
prefill launch-overhead wall, KV wire compression, the geo decode latency
floor, and cheap verifiable inference), each cross-referenced to the paper
that owns the surrounding result.
- hanzo-distributed-decode-latency, hanzo-consensus-zap-compute: consistency
pass (canonical f32 wire terminology; link goodput unified to 280 MB/s =
2.24 Gbit/s; precise f16-vs-bf16 root-cause wording).
INDEX.md regenerated via `make index`; besides the 4 above it also indexes 6
pre-existing root papers the previous index had missed. All four compile clean
with pdflatex (10/10/13/9 pages).
The canonical paper on main claimed a five-voter quorum 'tolerating two
simultaneous failures' — physically impossible for BFT: f=2 needs N>=3f+1=7,
with a 2f+1=5 quorum. Corrects all 10 fault-model sites (abstract, two-plane
table, Topology, StatefulSet rolling-upgrade, Contributions recap, intro) to
seven voters / 5-of-7 quorum / f=2, adding the N>=3f+1 and 2f+1=5 rationale.
Rolling upgrade now correctly states maxUnavailable:1 keeps six-of-seven live,
above the five-of-seven quorum. HIP-0125 references untouched (main's number is
canonical; the stale paper-router-clean branch still said HIP-0116 and is
superseded by this in-place fix). Prose-only; inline-math $-balanced.
Co-authored-by: Hanzo Dev <[email protected]>
Restructure the 12-page monolith into one paper per concept, each self-
contained and teachable (concrete failure -> concept -> repo code -> eval for
that concept only), with hanzo-kernel-dsl.tex slimmed to a ~5-page umbrella that
cites the six rather than inlining their depth. Each fact lives in exactly one
paper (DRY). Shared preamble in shared/kernel-preamble.tex.
07 hanzo-kernel-dsl umbrella: thesis + guided tour
07.1 hanzo-fusion-is-composition functor law, fences, fused_interp, DAG
07.2 hanzo-comptime-autotune schedule-as-value, byte-identical variants
07.3 hanzo-intrinsic-islands oracle-anchored escape hatch vs forks
07.4 hanzo-bitexact-oracle CPU oracle law + nightly 3-backend CI
07.5 hanzo-int8-mmq-negative-result opaque WMMA fragment, sync-bound proof
07.6 hanzo-collapse-methodology ledger + verify-then-delete + migrations
All 7 build via the Makefile (auto-discovered) with zero undefined refs.
- site (papers.hanzo.ai): add hanzo-unified-tenant-cloud to the measured
infrastructure section and serve its PDF
- INDEX.md: regenerate — now covers all 198 standalone papers (was 175,
missing kernel-dsl/kernel-optimization/router/unified-tenant-cloud et al);
add scripts/gen-index.sh + make index so the catalogue stays honest
- README: general-availability note + unified-tenant-cloud highlight
- cover: drop the CONFIDENTIAL stamp — the catalogue is published
Co-authored-by: Hanzo Dev <[email protected]>
One Rust GPU-kernel DSL that collapses the backends x ops x types product:
fusion as morphism composition (functor law + Reduce/Scan fences), comptime-
specialized autotune, intrinsic islands, and a CPU bit-exact oracle. Includes
cross-backend bit-exactness evidence, the dp4a 118%-of-hand-tuned and 7.1x
add_rmsnorm migration wins, the int8 tensor-core MMQ negative result, the
52,345-line collapse ledger, and the nightly 3-backend GPU CI.
Basis for the agentic-coding dataset: version-control survival as a time-validated
quality label; shapes-that-last; the 3 co-registered layers (transcripts/diffs/
outcomes) + human-vs-AI axis; construction pipeline (extract/normalize/link/redact/
format) with fleet aggregation + HF backup; SFT/preference/RL/survival-holdout.
Co-authored-by: Hanzo Dev <[email protected]>
Measured head-to-head vs llama.cpp on the same silicon: the flash-attn dense-prefill
result on GB10 (+42%, still 0.77-0.84x, stated honestly as the one trailing axis),
the CUDA decode-graph / MoE-prefill / GDN-kernel leads, AMD gfx1151 prefill+decode,
and cross-backend decode parity. Compiles clean (13 pp).
AICoinMiner -> AIMiner across prose, status table, and bibliography.
Contract paths updated to contracts/ai/{mining,compute,token}/ (no
ai/thinking/). 'Thinking' no longer appears as any contract/protocol/
type name; 'Thinking Chains' survives only as the loose category phrase.
No change to the Hamiltonian Market Maker math, theorems, test counts,
or technical content. PoT = Proof of Training (a PoAI proof) untouched.
Recompiled clean with latexmk (23 pages).
Part I (proof) tightened and grounded line-for-line in shipped code:
- correct stale test counts to measured values (poi.rs 7, poi_graph 9,
poi_transcript 8, Go crypto/poi 22 funcs; forge: MinerStakeRegistry 8,
AICoinMiner 12, AIComputeRegistry 6, AICoin 11)
- add typed graph-composition soundness (Thm: well-formed + locally-correct
=> committed output equals deterministic forward pass; poi_graph.rs)
- add information-theoretic / post-quantum soundness proposition + PQ envelope
(ML-DSA/SLH-DSA/X-Wing/P3Q)
Part II (price) — the Hamiltonian Market Maker, fully derived and proven:
- phase space (q,p), cost potential C, Hamiltonian H = pq - C(q) = conjugate
C*(p) on the quote manifold (bonded value; no unforced 'physics' terms)
- Thm path-independence; Thm zero-cost round-trip / no in-curve arbitrage;
Thm bounded subsidy with LMSR b·ln N as the entropic special case;
Thm monotone price-supply law (the PoAI coupling); Prop convex slippage;
Prop Uniswap divergence-loss; multi-asset generalization
- LMSR (Hanson) and Uniswap x·y=k shown as two potentials of one frame
- bind the curve to verified supply: MinerStakeRegistry (bonded/slashable),
AICoinMiner no-proof-no-mint, AIComputeRegistry network-wide no-double-mint,
AICoin capped halving issuance — all read from luxfi/standard contracts/ai/thinking
Integrity fixes during review: removed a FALSE angular-momentum conservation
claim (the {L_ij,H}=0 identity does not hold for a cost-function maker; replaced
with the genuine discrete permutation symmetry + an explicit remark on why the
tempting claim is false); made the trade-vs-relaxation dynamics honest.
No fabricated benchmarks. Every empirical number is a measured test count; every
HMM claim is a theorem with a proof. Compiles clean: 23 pages, 0 errors.
Standalone paper: PoAI builds ON the Hanzo engine — the proof is emitted as a
side-effect of native inference/training/embedding execution. Freivalds over the
exact int8 accumulator in F_p (p=2^61-1), the four proofs (PoE/PoI/PoT/PoC) over
one workloadType primitive, determinism prerequisites, commit-now/verify-later
ActivationTraceMMR, the measured-weights reportData binding, floating-point by
tier, architecture-family coverage, and ownership. Honest status incl. the
node-binary support rows (hanzo-engine v1.2.5 / hanzod / luxd / zood). 10pp.
The DOKS-direct deploy job was wrong (CI must not touch the cluster directly)
and also lacked the token. Keep the working self-hosted build→GHCR half; the
native operator rollout is handled by platform.hanzo.ai via the Hanzo Platform
GitHub App + .platform.yml (wiring tracked separately).
Replace the GitHub Pages publish (broken since 2026-04-10 on the org-wide
Actions artifact-storage quota) with a standard GHA workflow that runs entirely
on Hanzo infra: build the Next.js static export into a hanzoai/static image on
the self-hosted hanzo-build-linux-amd64 pool, push to ghcr.io/hanzoai/papers,
then roll it onto the operator-managed `papers` Service CR (hanzoai/ingress +
static plugin) from hanzo-deploy-linux-amd64. No GitHub-hosted builders, no
Pages artifact quota, no kaniko/PAT. DNS cutover (Cloudflare → hanzo-k8s LB) is
the remaining one-time step.
Nav link + PDF bookmark still said 'Sovereign vs. Closed' (pre-rename, b314046).
Aligned both to the paper's current title and rebuilt the 196-page bundle so it
carries the corrected ~90% vs-claude paper.
The 'Cost at scale' section claimed cloud spend 'fell approximately 97%',
contradicting this paper's own ~90% ($35K->$3.5K/mo, ~$380K/yr) and the
canonical cloud-economics staging (achieved ~90%; ~97%/$1,200/mo is the
not-yet-reached target). Also matches the sentence's own 'order-of-magnitude'
framing. Rebuilt PDF + synced to site/public/pdfs (deploys to papers.hanzo.ai).
- hanzo-vs-claude: prominent 'one engineer on Hanzo stack vs team on Claude' section
(anonymized audit: ~250-900x lower $/LoC) + theoretical mechanism + switch CTA.
- one-pager: cloud-cost aligned to ~$3.5K/mo (~90%, ~$380K/yr) matching the paper;
suite count 16->22.
- site: real Hanzo mark (@hanzo/logo) in header; PDF embed hides TOC/thumbnail sidebar
(navpanes/toolbar=0); vs-claude card abstract leads with the productivity hook.
- README: added the 6-paper engine cluster.
Design paper describing the Hanzo unified Go binary architecture:
one statically linked process (hanzoai/cloud) mounting every platform
subsystem, built on the zip framework (Fiber v3) with embedded goja
for in-process JS, esbuild for TS->ES5 transpilation, and ZAP RPC
serving both the wire and the in-process dispatch seam.
Covers motivation (microservices overhead for co-located control
planes), architecture, the TS->goja->native-Go migration path
(esign tRPC->ZAP case study, 14/14 routers server-side),
multi-tenancy by configuration, the in-process-goja vs sandboxed
hanzoai/runtime code-execution boundary, a cost model anchored in
published service-mesh measurements, and performance (function call
vs network RPC, promise pipelining).
8 pages, two TikZ figures (layered architecture, cost comparison),
20 references. Compiles clean with tectonic; no missing citations.
One content-addressed, post-quantum-encrypted block substrate over S3 with two
surfaces: in-process SQLite VFS (hanzovfs) for structured tenant state, and a
read/write FUSE mount for Dropbox-class file sync. Per-object DEKs sealed with
hybrid ML-KEM-768 + X25519 (luxfi/age), ChaCha20-Poly1305 bulk. Realizes
HIP-0302 + HIP-0107.
Co-authored-by: Hanzo Dev <[email protected]>
Fix shared/ include paths to ../shared/ for 55 subdirectory papers so
that hanzocover.sty and lstlang.tex resolve when building from each
paper's own directory (the build pattern used by latexmk per paper).
Build fixes:
- hanzo-operative/sections/03-screen-understanding-pipeline.tex: move
\COMMENT from after \FOR{...} onto the \STATE line so the algorithmic
env doesn't mis-parse.
- hanzo-network-architecture (abstract + sections 04, 12, 13): escape
unicode mu (U+03BC) as $\mu$ for pdflatex.
- ntt-transform/sections/08-benchmark-results.tex: same mu escape.
All 55 Tier-2/3 papers now build clean with latexmk -pdf.
Add section 23 with literature-backed comparison scaffolds for:
- AI agent frameworks: vs LangGraph, AutoGen, CrewAI, OpenAI Agents SDK
- LLM inference engines: vs vLLM, TGI, TensorRT-LLM
Hanzo column entries marked [TBD-measure] until a controlled re-run
on the competitor's published harness is completed. Competitor cells
sourced to repos, papers, and third-party benchmark articles.
Reproducibility spec (hardware, models, software pins, decision rule)
documents what is needed to fill the [TBD] cells honestly.
No invented numbers; existing internal claims in sec 17/16 retained but
flagged in section 23 as not-yet-apples-to-apples vs literature.
GPU-native AI compute network with DEX+EVM+FHE triumvirate. Documents
the four-version chronology (1.0 initial AI compute -> 2.0 Hamiltonian
LLMs + AI Coin -> 3.0 full PQ -> 4.0 GPU-native sovereign L1), the
HMM (Hanzo Market Maker) native AI-compute DEX cross-listed via
Liquidity Protocol with Lux D-Chain and Zoo DEX, the AIVM opcode
surface (8 precompiles 0x0a01-0x0a08), confidential AI inference
on F-Chain (FHE), Proof-of-AI mining, and on-mainnet receipts at
h_0=36,963,000.
- hanzo-4-0-launch/hanzo-4-0-launch.tex (8 pages)
- INDEX.md
- hanzo-ico-infrastructure: redate to 2017 (Techstars year), expand
from 254 to ~600 lines of detailed token sale platform description
- hanzo-payments-platform: new 2018 paper on the crypto-commerce
platform with Bitcoin/Ethereum payment rails, fiat settlement,
and merchant API
zeekay
