The paper architected investor onboarding around a named KYC vendor from the
satschel lineage — 13 references across five files, including two TikZ nodes and
a \bibitem. That name must not appear in a Hanzo paper.
The architecture is unchanged and is legitimately ours: an external KYC provider
returns a signed attestation by webhook, compliance validates it, the investor
lands in IAM and then on the on-chain ComplianceRegistry. Only the vendor's
identity is removed, so the paper still says exactly what it said.
The \bibitem was never \cite'd — checked before deleting rather than assuming,
since removing a cited key breaks every reference to it. Both TikZ node ids were
renamed with their \draw edges in the same pass, so the diagrams still connect.
Rebuilt: pdflatex clean, 6 bibitems, 165787 bytes.
Co-authored-by: Hanzo Dev <[email protected]>
The diagram had the mirror pointing the wrong way and credited a
.github/workflows/sync.yml that 5fe7ef8 deleted — .github/ holds no workflow
now. What exists is a Gitea push mirror on the forge's copy of this repo,
sync_on_commit, addressed at github.com. Nothing carries refs back, so a commit
pushed to the GitHub remote is built by nothing: the forge sits at 86bf488 while
GitHub main is two commits ahead of it, which is how that reads from the outside.
Co-authored-by: Hanzo Dev <[email protected]>
`make -k all` returned 0 over any number of broken papers, so CI was green the
whole time it existed. Four things had to be true for that:
- every recipe line ended in `|| true` and the rule printed "FAIL" instead of
exiting, so make never saw a failure;
- nonstopmode emits a PDF for almost any input, so "the PDF exists" is not
the same question as "the paper compiled" — zen-nano_whitepaper produced
one through 23 LaTeX errors;
- pdfs/ was tracked, so a checkout handed the "check every paper came out"
step 100 of the PDFs it was about to look for;
- discovery was three wildcards, so 69 of the repo's 219 papers were
compiled by nothing at all, defense/ by a second copy of the same
swallowing loop written inline in ci.yml.
The rule is now one latexmk per paper and its exit status is the gate:
-halt-on-error (no PDF from a broken paper), -bibtex (a declared bibliography
must resolve rather than being skipped when the .bib is absent), -Werror (an
undefined citation is a defect, not a log note), -cd (each paper compiles from
its own directory, so zen/ finds references.bib and defense/ finds
hanzo-defense.sty). .DELETE_ON_ERROR so a failed run leaves nothing behind,
and pdfs/ is untracked because it is output.
Run against the tree it was guarding, the honest gate fails 24 papers:
6 \begin{itemize} with its backslash-b eaten, leaving a bare `egin{itemize}`
and no \end — artist, designer-instruct, eco, nano, next, omni
3 the same list with the opener deleted outright, so five \item stood in no
environment — artist-edit, designer-thinking, scribe
4 \and in a cover page's raw \@author: it expands to \end{tabular} and closed
a tabular nothing had opened, and \thanks left hyperref pointing at a
footnote anchor that was never created; plus five stray \end{table} at the
end of those documents — director, foley, musician, video
9 \color{gray} under \usepackage{color}, which defines eight names and not
that one — xcolor is the superset the working papers already load
6 \bibliography{references} naming a database that was never written, so
every citation rendered [?] — zen/references.bib now holds all 27 works
9 \bibliographystyle+\bibliography in papers with no \cite at all — dropped
3 characters pdflatex has no glyph for: CO₂ -> CO\textsubscript{2},
↔ -> $\leftrightarrow$, Persian letters -> their code points, the
SentencePiece marker -> \textvisiblespace
1 \IF{...} \COMMENT{...}: algorithmic's \IF opens a list and the comment
landed in it before any \item; the comment slot is \IF[...]{...}
1 \ref{eq:anchor_update} to an equation the paper never writes
All 219 papers now compile from a clean tree: `make -k all` exits 0.
Co-authored-by: Hanzo Dev <[email protected]>
Two papers claimed the platform was built on a third-party identity server.
It is not: hanzoai/iam is clean-room original work, and its LICENSE states
it carries no third-party licensed source. The derived server was
hanzoai/iam-v1, retired and in no current product.
hanzo-iam-platform.tex now says only what the rest of the section supports
(a ground-up rewrite, KrakenD retained). The harness paper says Hanzo IAM
maps channel identities through its own federation layer; the vendor
citation and its bibliography entry are dropped with it. Casbin, a
different dependency, is untouched.
The compiled PDFs still carry the old text and need a LaTeX rebuild.
Co-authored-by: Hanzo Dev <[email protected]>
An audit of all 68 published papers found that 51 were machine-generated in a
three-day window and carry no measurement of a Hanzo system: across the
29-paper product block, 711 numeric claim-sites yielded zero measured values.
They are backdated on the live site to 2024-2025. The defects are not subtle
and a reader disproves them with a browser and a calculator — a paper reports
9.2 million blocks per second, one block per 108 nanoseconds; another reports
8,412,893 jobs processed on a chain that answers net_peerCount with zero, and
a second paper reports the identical figure for a different system; a third
prints a user total its own arithmetic contradicts by 170x. Two papers on
retrieval and inference cite benchmark placements that appear on no
leaderboard.
The site keeps twelve papers. Each is from the human lane, each names its
harness and its box, and several report losses — the engine paper's Vulkan,
ROCm and Metal rows are all below parity, which is precisely why it can be
trusted about the one win it claims. Everything removed stays in git; nothing
is lost, and a paper returns when it can support what it says.
Three of the twelve needed a correction first. hanzo-cloud-economics headlined
3.5M lines of dead code deleted while stating 3.07M -> 1.06M one clause later;
the difference is 2.0M and the paper now says so. hanzo-network-whitepaper
claimed 29.5x storage savings as an observation — it is BitDelta's published
result and is now attributed, and its date no longer precedes the work.
hanzo-unified-tenant-cloud cited HIP-0032, which was deleted with the rest of
the contradicted standards; the concern lives in HIP-0405.
Co-authored-by: Hanzo Dev <[email protected]>
Three defects an audit found in published sources, each fixed at the source.
A control-plane IP was printed in a paper the site serves — hanzo-platform's
deployment section named the cluster's address, and the unified-harness paper
named two. A reader does not need our addresses to follow the argument, and an
attacker does not need to scan for them.
Two defense papers carried 'Approved for public release; distribution
unlimited'. That is a Department of Defense distribution statement, issued by a
review office after a review we have not requested and did not undergo. We may
publish these papers because they are ours; we may not claim a marking that
asserts a federal authority reviewed them.
refutation-driven-perf reported a ROCm decode win of 1.07x. That comparison was
refuted on 2026-07-20: the llama-HIP build it beat was a weak one, and against
a properly built llama on the same gfx1151 box we lose both phases — decode
0.91x, prefill 0.72x. Both are now in the table, marked open, and the two
prose restatements of the win are gone. A paper about refutation cannot be the
last place a refuted number survives.
Co-authored-by: Hanzo Dev <[email protected]>
The change that exposed the fsync cost also broke the FUSE mount, and the
mechanism generalises well past this codebase.
The mount's metadata cache implements the store configuration interface and
returned its own directory for EVERY key not ending in "backend". Reading a
newly-added syncWrites option therefore yielded "/tmp/<id>/meta"; the store
correctly rejected it and the mount died at startup. The store was right — the
configuration was wrong to invent an answer.
The defect is not the one key. A configuration that cannot express absence
mis-answers whichever option is added next, silently, at the call site
furthest from the mistake. So the regression test asserts the SILENCE on
unknown keys rather than any particular key.
Also names the two habits behind it, since neither is a bug on its own: a
variadic parameter that made a positional mistake compile, and an interface
with no "is this set?" predicate, which forces a three-state question through
a two-state type — the same shape as the downstream syncWrites bug, one layer
up. That symmetry is now the through-line of the section: two of the four
defects came from connection pooling, two from unset-vs-false collapsing.
Co-authored-by: Hanzo Dev <[email protected]>
The image job has failed on every run with
::error::REGISTRY_TOKEN is unset, so nothing was published. Add the org secret.
The guard is doing its job; the name is simply wrong. The hanzoai org defines
exactly GHCR_TOKEN, GHCR_USER, GH_PAT, KMS_CLIENT_ID, KMS_CLIENT_SECRET,
OCI_TOKEN and OCI_USER. There is no REGISTRY_TOKEN and never was, so the
suggested remedy — add the org secret — would have minted a second credential
for the registry every other repo already logs into with GHCR_*.
Only ui and papers invented that name. Both now use the GHCR_* pair, and take
the username from GHCR_USER instead of hardcoding hanzo-dev, so rotating the
publishing identity stays a single org-level change.
Tagging is untouched: still the short HEAD sha, which is what a CR pins.
Its log ends mid-step with no error line, no failure marker and no summary:
the truncated signature of a killed job. It ran during the window when
git.hanzo.ai was down (the forge pod was preempted and then blocked on an RWO
Multi-Attach while a storage-migration job held its volume), so the runner lost
the control plane mid-build.
Nothing in this repo changed. Empty commit to get a clean signal now the forge
is back.
Co-authored-by: Hanzo Dev <[email protected]>
Every paper compiled. The run's own check printed `missing: 0`, and the single
failing step is the artifact upload:
❌ Failure - Main actions/upload-artifact@v4
@actions/artifact v2.0.0+, upload-artifact@v4+ and download-artifact@v4+
are not currently supported on GHES
git.hanzo.ai is Gitea, which presents itself as GHES, and the v4 action refuses
on that basis before uploading anything. So the red badge was reporting an
action this forge cannot execute, not a broken paper — the worst kind of CI
failure, because it looks like the thing the job exists to check.
v3 speaks the artifact protocol the forge implements. Nothing else changes:
same name, same `pdfs/**/*.pdf` path, same 90-day retention, still
`if: always()` so the PDFs are captured even when a paper fails to build.
Co-authored-by: Hanzo Dev <[email protected]>
Measured the same logical operation at four depths with a client that speaks
ZAP straight to the filer:
ZAP, RAM-backed store 1.41 ms create / 1.14 ms lookup (712 / 879 per s)
ZAP, block-backed store 11.39 ms / 6.61 ms
filer HTTP, block store 8.36 ms
through the FUSE mount ~37 ms / ~5 ms
Only the backing store differs between the first two rows: same binary, same
transport, same client. So the store is disk-sync bound by roughly 8x, and the
transport's own floor is 1.41 ms — ZAP also beats the filer's HTTP surface on
identical storage. The earlier drafts blamed, in order, the concept and then
the FUSE layer. Both were wrong about where the time goes.
Entries are written one Put at a time. A batch path exists in the store and
the single-entry insert does not use it, so every metadata write pays its own
durable commit to a network block device. Lookups show the same shape
(6.61 vs 1.14 ms), so hot entries are not served from memory either.
FUSE still adds ~3x on top, and because each filesystem operation costs several
filer round trips, any per-round-trip reduction is multiplied by that fan-out —
which makes the store-layer fix the higher-leverage one despite FUSE being the
larger single term.
Conclusion updated accordingly: the per-link cost is not a constant of the
design. It is 1.41 ms of transport plus ~10 ms of durable commit plus a FUSE
multiplier, and two of those three are addressable without touching the
architecture.
Co-authored-by: Hanzo Dev <[email protected]>
The first revision measured its own instrument. It spawned a client process
per request, so every figure carried a DNS resolution and a TCP handshake: a
breakdown of one 15.2 ms request is 9.0 ms name lookup, 2.0 ms connect, 4.1 ms
of actual server work. On a reused connection a read is 2.263 ms, not the
15.67 ms published.
The tell was in the data before I went looking: a 1 KiB PUT measured slower
than a 64 KiB PUT. No server-side cost model produces that, and I should have
chased it instead of writing a cost model around it.
Correcting the numbers moves the conclusion. Driving creates against the
filer's own API on a pooled connection gives 8.36 ms (120/s); the same create
through the FUSE mount costs ~37 ms. So roughly 4.4x of the penalty is the
projection layer, not the object store — which is implementation, and tunable,
where the earlier draft called the whole gap inherent.
One tuning attempt (the driver ships its chunk read cache disabled) is
reported as inconclusive rather than as a result: it caches chunks for reads
while this workload is metadata-bound, the two runs did not time identical
scopes, and mount daemons restarted mid-measurement. The claim that survives
is narrower — a dependent metadata chain pays one round trip per link, and
whether that link costs 37 ms or 4 ms decides whether Git is impossible or
merely expensive. That number must be measured per layer, not assumed.
Co-authored-by: Hanzo Dev <[email protected]>
The Makefile discovers papers from *.tex at the root and zen/*.tex only, so a
paper in its own directory compiles for nobody: it is absent from `make
manifest`, which is the single definition of the paper set the CI gate checks.
That is how cloud-unified-binary and the other subdirectory papers sit outside
the gate today.
Moved to native-object-store-vfs.tex at the root, fixed the shared/ include
paths, rebuilt through the repo Makefile (OK), and regenerated INDEX.md.
Co-authored-by: Hanzo Dev <[email protected]>
Production measurements of hanzoai/s3 v1.0.4 and the ZAP-native CSI driver,
taken in-cluster against signed requests on the live deployment.
The headline is a negative result, and it inverts the plan the work started
from. The object store is fast (265.9 MiB/s on 16 MiB reads, 12.81 ms
metadata lookups, flat latency under concurrent mixed load) and the mount is
fast for bulk data (287 MB/s write, 685 MB/s read) — but its metadata plane
runs at 27 file creations and 201 stats per second. Measured on a real
metadata-bound workload, Git is 27x to 278x slower on the mount than on local
disk. So the Git forge should NOT be relocated onto it, even though the
forge's storage layer makes the change syntactically free.
The durability section says what we actually run rather than what the
architecture aspires to: replication is "000" (one copy), one volume server,
Recreate/replicas:1 on a single RWO volume, and luxfi/consensus is not a
dependency of this service. Replication and consensus over the metadata plane
are future work, and the paper says so instead of implying otherwise.
Also documents the three defects fixed en route — promise identifiers scoped
to the client rather than the connection, a metadata restore that silently
dropped every file, and head-of-line blocking on pooled connections — because
each defeated the check that should have caught it, and those reasons
generalise.
Co-authored-by: Hanzo Dev <[email protected]>
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).
zeekayandHanzo Dev